SwiftUI：解决间接遵循View协议的结构体初始化报错问题

场景复现 #

我定义了一个遵循View协议的协议Foo：

protocol Foo: View {
    init(field: Binding<Bool>)
}

随后实现了两个遵循该协议的结构体：

struct BarView: Foo {
    @Binding private var field: Bool
    
    init(field: Binding<Bool>) {
        self._field = field
    }
    
    var body: some View {
        Text(field ? "Some text" : "Some other text")
    }
}

struct QuxView: Foo {
    @Binding private var field: Bool
    
    init(field: Binding<Bool>) {
        self._field = field
    }
    
    var body: some View {
        Text(field ? "Some text" : "Some other text")
    }
}

在主视图中，我维护了一个Foo协议类型的数组，尝试初始化视图时出现错误：Type 'any Foo' cannot conform to 'View'，主视图代码如下：

struct MainView: View {
    static let fooViews: [any Foo.Type] = [
        BarView.self,
        QuxView.self
    ]
    @State private var field = false
    
    var body: some View {
        if let fooView = MainView.fooViews.first {
            fooView.init(field: $field)
        }
    }
}

解决方案 #

问题核心在于：SwiftUI的View协议包含关联类型Body，使用any Foo这种存在类型时，编译器无法在编译期确定具体的Body类型，因此无法满足View的协议要求。以下是三种可行的解决思路：

方法1：用AnyView直接包装（最简方案） #

直接通过AnyView对初始化后的any Foo实例进行类型擦除，让编译器识别为合法的View：

struct MainView: View {
    static let fooViews: [any Foo.Type] = [
        BarView.self,
        QuxView.self
    ]
    @State private var field = false
    
    var body: some View {
        if let fooType = MainView.fooViews.first {
            AnyView(fooType.init(field: $field))
        }
    }
}

这种方式会带来少量类型擦除的性能开销，但实现简单，适合轻量场景。

方法2：自定义类型擦除包装器（更可控） #

创建专门的类型擦除结构体，封装any Foo实例，避免直接依赖AnyView：

struct ErasedFooView: View {
    private let makeContent: () -> any View
    
    init<F: Foo>(_ foo: F) {
        self.makeContent = { foo }
    }
    
    var body: some View {
        makeContent().eraseToAnyView()
    }
}

// 给Foo协议扩展便捷方法
extension Foo {
    func erased() -> ErasedFooView {
        ErasedFooView(self)
    }
}

修改主视图的初始化逻辑：

struct MainView: View {
    static let fooViews: [any Foo.Type] = [
        BarView.self,
        QuxView.self
    ]
    @State private var field = false
    
    var body: some View {
        if let fooType = MainView.fooViews.first {
            let fooInstance = fooType.init(field: $field)
            ErasedFooView(fooInstance)
        }
    }
}

方法3：改用闭包数组存储视图构造逻辑（编译期安全） #

放弃存储协议类型，改为存储返回any View的构造闭包，让编译器保留具体类型信息：

struct MainView: View {
    // 存储接收Binding并返回View的闭包
    static let fooViewCreators: [(Binding<Bool>) -> any View] = [
        { BarView(field: $0) },
        { QuxView(field: $0) }
    ]
    @State private var field = false
    
    var body: some View {
        if let creator = MainView.fooViewCreators.first {
            creator($field)
        }
    }
}

这种方式没有类型擦除的性能损耗，且编译期就能保证类型安全，是最推荐的方案。

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