Swift iOS：带视图依赖的CommonViewController正确继承方案

Hey Dan, let's work through this cleanly—here's a non-hacky, Swift-native approach to build your reusable background-enabled view controller without repeating code or relying on fragile IBOutlet assumptions across subclasses:

1. Define a Protocol to Standardize Background View Access #

First, create a protocol that enforces any subclass of your CommonViewController to expose a background view. This lets your base controller rely on a consistent interface instead of hardcoding property names:

protocol BackgroundProviding: UIViewController {
    var backgroundView: UIView { get }
}

We constrain it to UIViewController so we know any conforming type is a view controller (keeps things type-safe).

2. Build the Common Base Controller #

Now implement your CommonViewController with all the shared logic—rotation handling, status bar style, etc.—and use the protocol to safely access the background view from subclasses:

class CommonViewController: UIViewController {
    // Shared status bar style
    override var preferredStatusBarStyle: UIStatusBarStyle {
        return .lightContent // Adjust to your needs
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Initialize background layout when the view loads
        guard let backgroundProvider = self as? BackgroundProviding else {
            fatalError("All subclasses of CommonViewController must conform to BackgroundProviding!")
        }
        updateBackgroundLayout(for: view.bounds.size, backgroundView: backgroundProvider.backgroundView)
    }

    // Shared rotation adaptation logic
    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
        guard let backgroundProvider = self as? BackgroundProviding else { return }
        
        coordinator.animate(alongsideTransition: { _ in
            self.updateBackgroundLayout(for: size, backgroundView: backgroundProvider.backgroundView)
        })
    }

    // Reusable background layout update method
    private func updateBackgroundLayout(for size: CGSize, backgroundView: UIView) {
        backgroundView.frame = view.bounds
        
        // If your background is an image view, add shared image-specific logic here
        if let imageView = backgroundView as? UIImageView {
            imageView.contentMode = .scaleAspectFill
            imageView.clipsToBounds = true
        }
    }
}

The fatalError in viewDidLoad acts as a safety net during development—you'll immediately know if a subclass forgets to conform to the protocol.

3. Implement Subclasses with Storyboard Support #

For each new scene, create a subclass of CommonViewController, conform to BackgroundProviding, and link your background view from Storyboard via IBOutlet:

Step 3.1: Create the Subclass #

class CustomViewController: CommonViewController, BackgroundProviding {
    // Link this IBOutlet to your background image view in Storyboard
    @IBOutlet weak var backgroundImageView: UIImageView!

    // Conform to BackgroundProviding protocol
    var backgroundView: UIView {
        return backgroundImageView
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Add subclass-specific logic here
        backgroundImageView.image = UIImage(named: "your-custom-background")
    }
}

Step 3.2: Configure Storyboard #

1. Set your scene's view controller class to CustomViewController
2. Drag a UIImageView (or your custom BackgroundImageView class, see below) into the view hierarchy, send it to the back, and size it to fill the view
3. Link the image view to the backgroundImageView IBOutlet in your subclass

Optional: Reusable Background View Class #

If all your backgrounds share styling (like aspect fill, clips to bounds), create a custom image view class to encapsulate that logic:

class BackgroundImageView: UIImageView {
    override init(frame: CGRect) {
        super.init(frame: frame)
        commonSetup()
    }

    required init?(coder: NSCoder) {
        super.init(coder: coder)
        commonSetup()
    }

    private func commonSetup() {
        contentMode = .scaleAspectFill
        clipsToBounds = true
        // Add any other shared styling (e.g., blur effects, tint colors)
    }
}

Then just set your Storyboard image view's class to BackgroundImageView—no need to repeat setup code in each subclass.

Why This Works #

• No hacks: Uses Swift's native protocol-oriented programming, no runtime tricks or fragile string-based property access
• DRY (Don't Repeat Yourself): All shared logic lives in CommonViewController—subclasses only handle their unique needs
• Flexible: Subclasses can use Storyboards, XIBs, or code to create their background view, as long as they conform to the protocol
• Type-safe: The protocol ensures your base controller always has access to a valid background view

内容的提问来源于stack exchange，提问作者Dan