SwiftUI中使用同一视图绑定编辑不同枚举的实现方案

枚举绑定类型不匹配的解决方案 #

你的两个枚举都是基于String rawValue的类型，最优雅的解决方式是用泛型+协议约束直接让子视图支持这类枚举，避免手动类型转换。

方案1：泛型枚举Picker视图 #

先定义你的String类型枚举（需遵守CaseIterable用于遍历所有选项）：

enum ReferenceStockStatus: String, CaseIterable {
    case inStock = "有库存"
    case outOfStock = "无库存"
    case pending = "待补货"
}

enum ReferenceGoneStatus: String, CaseIterable {
    case active = "有效"
    case archived = "已归档"
    case deleted = "已删除"
}

然后编写泛型Picker子视图，约束泛型类型为RawRepresentable（支持rawValue）、CaseIterable（遍历枚举值）且RawValue为String：

struct GenericEnumPicker<T: RawRepresentable & CaseIterable & Hashable>: View where T.RawValue == String {
    let title: String
    @Binding var selection: T
    
    var body: some View {
        Picker(title, selection: $selection) {
            ForEach(T.allCases, id: \.self) { enumCase in
                Text(enumCase.rawValue).tag(enumCase)
            }
        }
        .pickerStyle(.menu) // 可替换为你需要的样式
    }
}

在父视图中直接传入枚举绑定即可，完全不需要类型转换：

struct ParentView: View {
    @State private var stockStatus: ReferenceStockStatus = .inStock
    @State private var goneStatus: ReferenceGoneStatus = .active
    
    var body: some View {
        VStack(spacing: 20) {
            GenericEnumPicker(title: "库存状态", selection: $stockStatus)
            GenericEnumPicker(title: "数据状态", selection: $goneStatus)
        }
        .padding()
    }
}

方案2：临时绑定转换（非泛型） #

如果不想用泛型，可手动将枚举Binding转为String Binding，适合临时场景：

// 原有String类型Picker子视图
struct StringPicker: View {
    let title: String
    let options: [String]
    @Binding var selection: String
    
    var body: some View {
        Picker(title, selection: $selection) {
            ForEach(options, id: \.self) { option in
                Text(option).tag(option)
            }
        }
    }
}

// 在父视图中转换绑定
let stockStatusStringBinding = Binding<String>(
    get: { stockStatus.rawValue },
    set: { newValue in
        if let newStatus = ReferenceStockStatus(rawValue: newValue) {
            stockStatus = newStatus
        }
    }
)

// 使用转换后的绑定
StringPicker(title: "库存状态", options: ReferenceStockStatus.allCases.map(\.rawValue), selection: stockStatusStringBinding)

这种方式复用性差，仅适合临时需求。

除了枚举，针对Picker、List等场景，通用实现主要有以下几种：

1. 泛型视图（最常用） #

通过泛型+协议约束，让视图支持符合条件的任意类型。比如通用List行视图：

struct GenericRowView<T: Identifiable>: View {
    let item: T
    let titleKey: KeyPath<T, String>
    let subtitleKey: KeyPath<T, String>?
    
    var body: some View {
        HStack {
            Text(item[keyPath: titleKey])
                .font(.headline)
            Spacer()
            if let subtitleKey = subtitleKey {
                Text(item[keyPath: subtitleKey])
                    .font(.subheadline)
                    .foregroundColor(.secondary)
            }
        }
        .padding()
    }
}

// 定义两个不同模型
struct Product: Identifiable {
    let id = UUID()
    let name: String
    let stock: String
}

struct Order: Identifiable {
    let id = UUID()
    let orderNumber: String
    let status: String
}

// 在List中复用通用行视图
List(products) { product in
    GenericRowView(item: product, titleKey: \.name, subtitleKey: \.stock)
}

List(orders) { order in
    GenericRowView(item: order, titleKey: \.orderNumber, subtitleKey: \.status)
}

2. 协议抽象（复杂场景） #

如果不同类型有共同行为，可定义协议抽象共性，让视图依赖协议而非具体类型。比如定义可选择选项协议：

protocol SelectableOption {
    var displayTitle: String { get }
    var uniqueId: String { get }
}

// 让枚举和其他类型遵守协议
extension ReferenceStockStatus: SelectableOption {
    var displayTitle: String { rawValue }
    var uniqueId: String { rawValue }
}

extension String: SelectableOption {
    var displayTitle: String { self }
    var uniqueId: String { self }
}

// 通用Picker视图
struct CommonPicker<Option: SelectableOption & Hashable>: View {
    let title: String
    let options: [Option]
    @Binding var selection: Option
    
    var body: some View {
        Picker(title, selection: $selection) {
            ForEach(options, id: \.uniqueId) { option in
                Text(option.displayTitle).tag(option)
            }
        }
    }
}

这种方式灵活性更高，可扩展更多共性属性（如图标、颜色）。

3. 类型擦除（谨慎使用） #

万不得已时可使用Any类型配合类型检查，但会丢失类型安全，容易引发崩溃：

struct AnyPicker: View {
    let title: String
    let options: [Any]
    let displayClosure: (Any) -> String
    @Binding var selection: Any
    
    var body: some View {
        Picker(title, selection: $selection) {
            ForEach(options, id: \.hashValue) { option in
                Text(displayClosure(option)).tag(option)
            }
        }
    }
}

// 使用时需强制类型转换
AnyPicker(
    title: "库存状态",
    options: ReferenceStockStatus.allCases,
    displayClosure: { ($0 as! ReferenceStockStatus).rawValue },
    selection: $stockStatus
)

内容的提问来源于stack exchange，提问作者alex.bour