协议遵循Identifiable后SwiftUI报错：any Model无法适配的解决方法

问题代码 #

protocol Model: Identifiable where ID == String? {
    var id: Self.ID { get set }
}

struct WidgetModel: Model {
    var id: String?
}

struct ContentView: View {
    let models = [any Model]()
    let model : any Model = WidgetModel()
    var body: some View {
        //example 1
        ForEach(models) { _ in
        }
        //example 2
        .sheet(item:model) {
        }
    }
}

编译错误 #

Type 'any Model' cannot conform to 'Identifiable'

尽管协议已明确限定ID == String?，但any Model作为存在类型，目前无法被SwiftUI识别为符合Identifiable协议，这是Swift当前的类型系统限制。以下是两种通用的绕过方案，适用于所有需要Identifiable的SwiftUI组件（而非仅扩展ForEach）：

方案1：类型擦除包装器 #

创建一个具体的Identifiable结构体，包装any Model实例，显式实现Identifiable协议要求：

protocol Model: Identifiable where ID == String? {
    var id: Self.ID { get set }
}

struct WidgetModel: Model {
    var id: String?
}

// 类型擦除包装器，实现Identifiable
struct AnyIdentifiableModel: Identifiable {
    let id: String?
    let base: any Model
    
    init(_ base: any Model) {
        self.base = base
        self.id = base.id
    }
}

struct ContentView: View {
    // 使用包装后的类型创建数组和单个实例
    let models = [AnyIdentifiableModel(WidgetModel(id: "1")), AnyIdentifiableModel(WidgetModel(id: "2"))]
    @State var model: AnyIdentifiableModel? = AnyIdentifiableModel(WidgetModel(id: "3"))
    
    var body: some View {
        ForEach(models) { wrappedModel in
            // 通过base访问原Model实例
            Text(wrappedModel.base.id ?? "无ID")
        }
        .sheet(item: $model) { wrappedModel in
            Text("Sheet内容：\(wrappedModel.base.id ?? "无ID")")
        }
    }
}

该方案通用性强，无论新增多少Model的实现类型，只需通过AnyIdentifiableModel包装即可，所有依赖Identifiable的SwiftUI组件都能直接使用。

方案2：枚举封装模型类型 #

如果你的Model实现类型有限且可控，可以用枚举统一封装所有类型，让枚举本身符合Identifiable：

protocol Model: Identifiable where ID == String? {
    var id: Self.ID { get set }
}

struct WidgetModel: Model {
    var id: String?
}

struct AnotherWidgetModel: Model {
    var id: String?
    var extraInfo: String
}

// 枚举封装所有Model类型，实现Identifiable
enum ModelEnum: Identifiable {
    case widget(WidgetModel)
    case anotherWidget(AnotherWidgetModel)
    
    var id: String? {
        switch self {
        case .widget(let model): return model.id
        case .anotherWidget(let model): return model.id
        }
    }
}

struct ContentView: View {
    let models: [ModelEnum] = [
        .widget(WidgetModel(id: "1")),
        .anotherWidget(AnotherWidgetModel(id: "2", extraInfo: "测试数据"))
    ]
    @State var model: ModelEnum? = .widget(WidgetModel(id: "3"))
    
    var body: some View {
        ForEach(models) { modelEnum in
            // 通过switch处理不同类型的模型
            switch modelEnum {
            case .widget(let model):
                Text(model.id ?? "无ID")
            case .anotherWidget(let model):
                Text("\(model.id ?? "无ID")：\(model.extraInfo)")
            }
        }
        .sheet(item: $model) { modelEnum in
            switch modelEnum {
            case .widget(let model):
                Text("Widget Sheet：\(model.id ?? "无ID")")
            case .anotherWidget(let model):
                Text("Another Widget Sheet：\(model.id ?? "无ID")")
            }
        }
    }
}

这种方案更直观，无需额外包装器，使用时可直接通过switch区分不同模型类型，适合模型种类较少且固定的场景。

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