SwiftUI中使用带关联类型的协议实现视图提供的编译错误解决方案咨询

这个问题我之前也碰到过，核心原因是Swift里带关联类型的协议不能直接当作普通类型来用——编译器没办法确定关联类型的具体实现，所以才会抛出那两个错误。给你两个实用的解决思路：

方法一：类型擦除包装器 #

我们可以创建一个类型擦除的结构体，把任意符合ViewProvider协议的类型包装起来，让编译器能明确识别变量的具体类型：

protocol ViewProvider {
    @ViewBuilder var viewOne: some View { get }
    @ViewBuilder var viewTwo: some View { get }
}

// 类型擦除的包装器，统一所有ViewProvider的对外类型
struct AnyViewProvider: ViewProvider {
    private let makeViewOne: () -> any View
    private let makeViewTwo: () -> any View
    
    // 初始化方法接收任意符合ViewProvider的类型
    init<Provider: ViewProvider>(_ provider: Provider) {
        self.makeViewOne = { provider.viewOne }
        self.makeViewTwo = { provider.viewTwo }
    }
    
    @ViewBuilder var viewOne: some View {
        makeViewOne()
    }
    
    @ViewBuilder var viewTwo: some View {
        makeViewTwo()
    }
}

struct ContentView: View {
    // 现在可以用AnyViewProvider作为@State的类型了
    @State private var parent: AnyViewProvider?
    var body: some View {
        VStack {
            HStack {
                Button(action: { parent = AnyViewProvider(Father()) }, label: { Text("Father") })
                Button(action: { parent = AnyViewProvider(Mother()) }, label: { Text("Mother") })
            }
            if let p = parent {
                p.viewOne
                p.viewTwo
            }
        }
    }
}

class Father: ViewProvider {
    @ViewBuilder var viewOne: some View {
        Text("Father One!")
    }
    @ViewBuilder var viewTwo: some View {
        Text("Father Two!")
    }
}

class Mother: ViewProvider {
    @ViewBuilder var viewOne: some View {
        Text("Mother One!")
    }
    @ViewBuilder var viewTwo: some View {
        Text("Mother Two!")
    }
}

这种方法的好处是保留了协议的扩展性，以后新增其他ViewProvider实现时，只需要创建新的类并包装到AnyViewProvider里即可。

方法二：用枚举替代协议 #

如果你的ViewProvider实现类型不多（比如只有Father和Mother两种），用枚举会更简洁，不需要额外的包装器：

// 用枚举承载所有成员类型的视图逻辑
enum FamilyMember {
    case father, mother
    
    @ViewBuilder var viewOne: some View {
        switch self {
        case .father:
            Text("Father One!")
        case .mother:
            Text("Mother One!")
        }
    }
    
    @ViewBuilder var viewTwo: some View {
        switch self {
        case .father:
            Text("Father Two!")
        case .mother:
            Text("Mother Two!")
        }
    }
}

struct ContentView: View {
    @State private var parent: FamilyMember?
    var body: some View {
        VStack {
            HStack {
                Button(action: { parent = .father }, label: { Text("Father") })
                Button(action: { parent = .mother }, label: { Text("Mother") })
            }
            if let p = parent {
                p.viewOne
                p.viewTwo
            }
        }
    }
}

这种写法更直观，代码量更少，但缺点是新增成员类型时需要修改枚举的switch分支，适合固定或少量的场景。

内容的提问来源于stack exchange，提问作者Gertjan.com