如何修改plist结构实现TableView静态与动态混合加载？

Hey there! Let's break down how to tweak your current setup to support both static plist-backed sections and dynamic network-driven sections, without relying solely on index paths for every case. Here's a step-by-step approach:

1. Refactor Your Plist Structure #

First, restructure your plist to explicitly define section types (static vs dynamic) and isolate their configurations. This replaces your flat container, headerIDS, and cellIDS arrays with a per-section config system:

<!-- Updated plist structure -->
<dict>
    <key>sectionConfigs</key>
    <array>
        <!-- Static Section (original plist-based) -->
        <dict>
            <key>type</key>
            <string>static</string>
            <key>headerID</key>
            <string>StaticHeader1</string>
            <key>cells</key>
            <array>
                <dict>
                    <key>cellID</key>
                    <string>StaticCellTypeA</string>
                    <key>cellContent</key>
                    <string>Static Cell 1 Content</string>
                </dict>
                <dict>
                    <key>cellID</key>
                    <string>StaticCellTypeB</string>
                    <key>cellContent</key>
                    <string>Static Cell 2 Content</string>
                </dict>
            </array>
        </dict>

        <!-- Dynamic Section (network-driven) -->
        <dict>
            <key>type</key>
            <string>dynamic</string>
            <key>headerID</key>
            <string>DynamicUserListHeader</string>
            <key>cellID</key>
            <string>DynamicUserCell</string>
            <key>dataIdentifier</key>
            <string>networkUserList</string> <!-- Maps to a variable in your code storing network data -->
        </dict>
    </array>
</dict>

2. Update Your Data Model #

Create codable models to parse this new plist structure, making it easy to distinguish between section types:

import Foundation

enum SectionType: String, Codable {
    case staticSection = "static"
    case dynamicSection = "dynamic"
}

struct SectionConfig: Codable {
    let type: SectionType
    let headerID: String
    let cells: [StaticCellConfig]? // Only for static sections
    let cellID: String? // Only for dynamic sections
    let dataIdentifier: String? // Key to fetch corresponding network data
}

struct StaticCellConfig: Codable {
    let cellID: String
    let cellContent: String
    // Add other static cell properties as needed
}

3. Adjust Table View Data Source Logic #

Modify your table view data source methods to handle each section type independently, no longer tying everything to index paths directly:

class YourTableViewController: UITableViewController {
    // Store parsed section configs from plist
    var sectionConfigs: [SectionConfig] = []
    // Store dynamic network data (key matches dataIdentifier from plist)
    var dynamicDataStore: [String: [Any]] = [:]

    override func viewDidLoad() {
        super.viewDidLoad()
        loadPlistConfig()
        fetchDynamicData()
    }

    // Load and parse the updated plist
    private func loadPlistConfig() {
        guard let path = Bundle.main.path(forResource: "YourPlistName", ofType: "plist"),
              let data = try? Data(contentsOf: URL(fileURLWithPath: path)),
              let configs = try? PropertyListDecoder().decode([SectionConfig].self, from: data) else {
            return
        }
        sectionConfigs = configs
    }

    // Fetch network data and store it in dynamicDataStore
    private func fetchDynamicData() {
        // Example network call to get user list
        NetworkManager.fetchUsers { [weak self] users in
            self?.dynamicDataStore["networkUserList"] = users
            self?.tableView.reloadSections([1], with: .automatic)
        }
    }

    // MARK: - Table View Data Source
    override func numberOfSections(in tableView: UITableView) -> Int {
        return sectionConfigs.count
    }

    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        let config = sectionConfigs[section]
        switch config.type {
        case .staticSection:
            return config.cells?.count ?? 0
        case .dynamicSection:
            guard let dataKey = config.dataIdentifier else { return 0 }
            return dynamicDataStore[dataKey]?.count ?? 0
        }
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let config = sectionConfigs[indexPath.section]
        switch config.type {
        case .staticSection:
            guard let cellConfig = config.cells?[indexPath.row] else {
                return UITableViewCell()
            }
            let cell = tableView.dequeueReusableCell(withIdentifier: cellConfig.cellID, for: indexPath)
            cell.textLabel?.text = cellConfig.cellContent
            return cell
        case .dynamicSection:
            guard let cellID = config.cellID,
                  let dataKey = config.dataIdentifier,
                  let dataArray = dynamicDataStore[dataKey],
                  indexPath.row < dataArray.count else {
                return UITableViewCell()
            }
            let cell = tableView.dequeueReusableCell(withIdentifier: cellID, for: indexPath)
            // Configure dynamic cell with network data (example: User model)
            if let user = dataArray[indexPath.row] as? User {
                cell.textLabel?.text = user.name
                cell.detailTextLabel?.text = user.email
            }
            return cell
        }
    }

    override func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
        let config = sectionConfigs[section]
        return tableView.dequeueReusableHeaderFooterView(withIdentifier: config.headerID)
    }
}

Key Benefits of This Setup #

• Flexibility: Mix static plist sections and dynamic network sections seamlessly
• Maintainability: Each section's configuration is self-contained, making it easy to add/remove sections without rewriting index path logic
• Scalability: Add more dynamic sections by just updating the plist and fetching the corresponding network data

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