iOS MVC模式下枚举、类与UI组件关联的技术问询

Hey there! Let's break down your MVC-related questions step by step, using Swift and UIKit as our context since you're working with ViewController, buttons, and labels.

1. Linking UI Buttons to Enum Cases in ViewController #

First, let's tweak your Condition enum to make mapping easier (adding raw values and conforming to CaseIterable helps with iteration):

enum Condition: String, CaseIterable {
    case poor, fair, excellent, dan
}

There are two clean ways to connect buttons to enum cases:

Option 1: Use Button Titles Directly #

Match button titles (e.g., "Poor", "Fair") to the enum's raw value (lowercased), then link all buttons in a group to a single IBAction:

class ShoeViewController: UIViewController {
    var shoe = Shoe(color: .fair, laces: .fair)
    
    // Link all color-selection buttons to this action
    @IBAction func colorConditionTapped(_ sender: UIButton) {
        guard let title = sender.currentTitle?.lowercased(),
              let condition = Condition(rawValue: title) else { return }
        shoe.color = condition
        updateShoeDisplay() // Trigger label update
    }
    
    // Repeat for lace-selection buttons with a separate IBAction
    @IBAction func lacesConditionTapped(_ sender: UIButton) {
        guard let title = sender.currentTitle?.lowercased(),
              let condition = Condition(rawValue: title) else { return }
        shoe.laces = condition
        updateShoeDisplay()
    }
}

Option 2: Use IBOutlet Collections for Batch Setup #

If you have lots of buttons, group them in an IBOutletCollection to avoid manually linking each one:

class ShoeViewController: UIViewController {
    @IBOutlet var colorButtons: [UIButton]!
    @IBOutlet var laceButtons: [UIButton]!
    var shoe = Shoe(color: .fair, laces: .fair)
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Attach actions to all color buttons
        colorButtons.forEach { $0.addTarget(self, action: #selector(colorButtonTapped(_:)), for: .touchUpInside) }
        // Attach actions to all lace buttons
        laceButtons.forEach { $0.addTarget(self, action: #selector(laceButtonTapped(_:)), for: .touchUpInside) }
    }
    
    @objc private func colorButtonTapped(_ sender: UIButton) {
        guard let title = sender.currentTitle?.lowercased(),
              let condition = Condition(rawValue: title) else { return }
        shoe.color = condition
        updateShoeDisplay()
    }
    
    @objc private func laceButtonTapped(_ sender: UIButton) {
        guard let title = sender.currentTitle?.lowercased(),
              let condition = Condition(rawValue: title) else { return }
        shoe.laces = condition
        updateShoeDisplay()
    }
}

Both approaches keep your code organized and map buttons directly to enum cases without messy tag logic.

2. Is the Dictionary-Based String Generation & Loop Traversal Scheme Reasonable? #

Absolutely — this is a great, scalable approach, especially if you plan to add more properties to Shoe later. Let's refine it with automation to avoid manual dictionary maintenance:

First, update your Shoe class with the required methods, plus a bonus optimization using Mirror to auto-detect Condition properties:

class Shoe {
    var color: Condition
    var laces: Condition
    // Example of a future property — no extra code needed later!
    var sole: Condition = .fair
    
    init(color: Condition, laces: Condition) {
        self.color = color
        self.laces = laces
    }
    
    // Auto-generate a dictionary of all Condition properties
    private func conditionDictionary() -> [String: Condition] {
        var dict = [String: Condition]()
        let mirror = Mirror(reflecting: self)
        for child in mirror.children {
            guard let propertyName = child.label,
                  let condition = child.value as? Condition else { continue }
            dict[propertyName.capitalized] = condition
        }
        return dict
    }
    
    // Generate the formatted description string
    func generateConditionSummary() -> String {
        let conditionDict = conditionDictionary()
        var summary = ""
        for (property, condition) in conditionDict {
            summary += "\(property) is in \(condition.rawValue.capitalized) Condition\n"
        }
        return summary.trimmingCharacters(in: .newlines)
    }
    
    // Helper method to save state (e.g., to UserDefaults)
    func saveConditionState() {
        guard let data = try? JSONEncoder().encode(conditionDictionary()) else { return }
        UserDefaults.standard.set(data, forKey: "ShoeConditionState")
    }
}

Why this works: #

• Scalability: Add new Condition properties to Shoe without touching the dictionary or loop logic — Mirror handles the rest.
• Maintainability: No hardcoded property lists to update.
• Flexibility: The dictionary makes serialization (saving) straightforward, which pairs nicely with your helper method.

This scheme is absolutely solid and will save you time as your app grows.

3. Displaying Stored Properties with a Label & Auto-Updating #

Yes, you can absolutely use a label for this — and there are two reliable ways to make it auto-update when Shoe properties change:

Option 1: Property Observers + Closure Callback (iOS <13) #

Add didSet observers to Shoe properties and a closure to notify the view controller of changes:

class Shoe {
    var onConditionChange: (() -> Void)?
    
    var color: Condition {
        didSet { onConditionChange?() }
    }
    var laces: Condition {
        didSet { onConditionChange?() }
    }
    var sole: Condition = .fair {
        didSet { onConditionChange?() }
    }
    
    // ... init and other methods remain the same
}

Then in your view controller:

class ShoeViewController: UIViewController {
    @IBOutlet weak var shoeInfoLabel: UILabel!
    var shoe = Shoe(color: .fair, laces: .fair)
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set up the callback to update the label when properties change
        shoe.onConditionChange = { [weak self] in
            self?.updateShoeDisplay()
        }
        // Initialize the label on load
        updateShoeDisplay()
    }
    
    private func updateShoeDisplay() {
        shoeInfoLabel.text = shoe.generateConditionSummary()
    }
}

Option 2: Combine Framework (iOS 13+) #

For a more modern approach, use @Published and ObservableObject to auto-publish property changes:

import Combine

class Shoe: ObservableObject {
    @Published var color: Condition
    @Published var laces: Condition
    @Published var sole: Condition = .fair
    
    init(color: Condition, laces: Condition) {
        self.color = color
        self.laces = laces
    }
    
    // ... generateConditionSummary and save methods remain the same
}

Then in your view controller:

class ShoeViewController: UIViewController {
    @IBOutlet weak var shoeInfoLabel: UILabel!
    var shoe = Shoe(color: .fair, laces: .fair)
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Subscribe to property changes and update the label
        shoe.objectWillChange
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.updateShoeDisplay()
            }
            .store(in: &cancellables)
        
        updateShoeDisplay()
    }
    
    private func updateShoeDisplay() {
        shoeInfoLabel.text = shoe.generateConditionSummary()
    }
}

Both methods ensure the label updates instantly whenever any Shoe property changes — no manual calls needed after the initial setup.

内容的提问来源于stack exchange，提问作者Ty-wan Claxton