Swift中带Binding关联类型的枚举无法遵守Codable/Hashable协议的解决方法

核心问题在于Binding<Car>本身不遵循Hashable、Codable协议，直接将其作为枚举关联值会导致整个枚举无法自动合成这些协议的实现。以下是兼顾协议合规和传递可编辑Car需求的解决方案：

1. 调整枚举关联值设计（推荐方案） #

将枚举的关联值从Binding<Car>替换为Car.ID，通过ID关联对应的Car实例，这样枚举可以自动合成所需协议的实现：

// 先确保Car结构体本身遵循必要协议
struct Car: Identifiable, Hashable, Codable {
    let id: UUID
    var name: String
    var model: String
    // 其他业务属性
}

// 路由枚举现在可以自动合成Hashable、Codable、Identifiable的实现
enum CarViewRouter: Identifiable, Hashable, Codable {
    case carDetail(Car.ID)
    case carEditor(Car.ID)
    
    // Identifiable协议的id自动合成，直接用枚举自身作为唯一标识
    var id: Self { self }
}

2. 在视图层通过ID生成Binding传递给子视图 #

在持有Car数据源的父视图中，根据路由携带的ID找到对应的Car实例，生成Binding<Car>传递给子视图：

struct MainView: View {
    @State private var cars: [Car] = [
        Car(id: UUID(), name: "Tesla", model: "Model 3")
    ]
    @State private var currentRoute: CarViewRouter?
    
    var body: some View {
        NavigationStack(path: $currentRoute) {
            List(cars) { car in
                Button(car.name) {
                    currentRoute = .carEditor(car.id)
                }
            }
            .navigationDestination(for: CarViewRouter.self) { route in
                switch route {
                case .carDetail(let carId):
                    if let carIndex = cars.firstIndex(where: { $0.id == carId }) {
                        CarDetailView(car: $cars[carIndex])
                    }
                case .carEditor(let carId):
                    if let carIndex = cars.firstIndex(where: { $0.id == carId }) {
                        CarEditorView(car: $cars[carIndex])
                    }
                }
            }
        }
    }
}

// 子编辑视图示例
struct CarEditorView: View {
    @Binding var car: Car
    
    var body: some View {
        Form {
            TextField("车辆名称", text: $car.name)
            TextField("车型", text: $car.model)
        }
    }
}

3. 为什么不能直接用Binding作为关联值？ #

• Binding是状态引用的包装器，核心作用是传递值的读写权限，本身没有实现Hashable、Codable——它无法被哈希计算，也不能被编码存储。
• 路由枚举的职责应该是描述导航目标，而非持有视图状态引用，用ID关联的设计更符合单一职责原则。

4. 备选方案（不推荐，仅特殊场景使用） #

如果必须在路由中直接传递状态上下文，可以拆分路由类型与状态标识，手动实现协议：

// 先定义纯路由类型，自动合成协议
enum CarRouteType: Hashable, Codable {
    case carDetail
    case carEditor
}

// 封装路由类型与Car ID，手动实现协议
struct CarViewRouter: Identifiable, Hashable, Codable {
    let type: CarRouteType
    let carId: Car.ID
    
    // Identifiable的id用组合值实现
    var id: String { "\(type)-\(carId.uuidString)" }
    
    // 手动实现Hashable
    func hash(into hasher: inout Hasher) {
        hasher.combine(type)
        hasher.combine(carId)
    }
    
    static func == (lhs: CarViewRouter, rhs: CarViewRouter) -> Bool {
        lhs.type == rhs.type && lhs.carId == rhs.carId
    }
}

这种方案虽然可行，但代码冗余度高，优先推荐第一种ID关联的实现方式。

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