SwiftUI移除AnyView并解耦特定类型的技术方案问询

我有一个SwiftUI视图MainTabView，它接收包含TabItem数组的TabViewModel，通过ForEach构建TabView内容。当前实现中TabItem用AnyView存储视图，我希望：

• 移除AnyView
• 解耦视图与具体类型
• 了解该场景下的依赖注入方法

我曾尝试用协议实现，但替换泛型时出现Static method 'buildExpression' requires that 'Content' conform to 'AccessibilityRotorContent'等编译错误，或导致类型耦合。调整后得到了候选实现方案，想请教该方案的优化空间。

struct MainTabView<ViewModel: TabViewModelProviding>: View {
    
    @ObservedObject var viewModel: ViewModel
    
    var body: some View {
        TabView {
            ForEach(viewModel.tabs, id: \.title) { tab in
                createTabFor(tabType: tab.type)
                    .tabItem {
                        Image(systemName: tab.imageName)
                        Text(tab.title)
                    }
            }
        }
    }
    
    @ViewBuilder
    func createTabFor(tabType: TabType) -> some View {
        switch tabType {
        case .recipes:
            RecipeListView()
        case .settings:
            SettingsView()
        }
    }
}

protocol TabViewModelProviding: ObservableObject {
    var tabs: [TabItemProviding] { get }
}

class TabViewModel: TabViewModelProviding {
    @Published var tabs: [TabItemProviding] = [
        TabItem(title: "Recipes", imageName: "wineglass.fill", type: .recipes),
        TabItem(title: "Settings", imageName: "gearshape.fill", type: .settings)
    ]
}

enum TabType {
    case settings
    case recipes
}

protocol TabItemProviding {
    var title: String { get }
    var imageName: String { get }
    var type: TabType { get }
}

struct TabItem: TabItemProviding {
    let title: String
    let imageName: String
    let type: TabType
}

以下是几个可优化的方向，兼顾解耦、可维护性和依赖注入需求：

1. 简化视图创建逻辑，移除硬编码switch #

把视图创建逻辑从MainTabView中剥离，放到TabType的扩展里，避免视图与类型判断的耦合：

extension TabType {
    @ViewBuilder
    func makeView() -> some View {
        switch self {
        case .recipes:
            RecipeListView()
        case .settings:
            SettingsView()
        }
    }
}

修改MainTabView的body，直接调用该方法：

var body: some View {
    TabView {
        ForEach(viewModel.tabs, id: \.id) { tab in
            tab.type.makeView()
                .tabItem {
                    Image(systemName: tab.imageName)
                    Text(tab.title)
                }
        }
    }
}

后续新增TabType的case时，只需在makeView里添加对应的视图，无需修改MainTabView。

2. 优化ForEach的唯一标识 #

当前用title作为ForEach的id，存在重复风险。给TabItem添加唯一UUID标识：

protocol TabItemProviding {
    var id: UUID { get } // 新增唯一id
    var title: String { get }
    var imageName: String { get }
    var type: TabType { get }
}

struct TabItem: TabItemProviding {
    let id: UUID = UUID() // 自动生成UUID
    let title: String
    let imageName: String
    let type: TabType
}

然后ForEach改为ForEach(viewModel.tabs, id: \.id)，避免因title重复导致的视图更新异常。

3. 实现依赖注入支持 #

如果子视图（如RecipeListView、SettingsView）需要依赖ViewModel，可通过以下方式注入：

方式1：参数传递依赖 #

扩展makeView方法，接收子视图所需的ViewModel：

extension TabType {
    @ViewBuilder
    func makeView(recipeVM: RecipeViewModel, settingsVM: SettingsViewModel) -> some View {
        switch self {
        case .recipes:
            RecipeListView(viewModel: recipeVM)
        case .settings:
            SettingsView(viewModel: settingsVM)
        }
    }
}

在MainTabView中注入这些依赖：

struct MainTabView<ViewModel: TabViewModelProviding>: View {
    @ObservedObject var viewModel: ViewModel
    let recipeViewModel: RecipeViewModel
    let settingsViewModel: SettingsViewModel
    
    var body: some View {
        TabView {
            ForEach(viewModel.tabs, id: \.id) { tab in
                tab.type.makeView(recipeVM: recipeViewModel, settingsVM: settingsViewModel)
                    .tabItem {
                        Image(systemName: tab.imageName)
                        Text(tab.title)
                    }
            }
        }
    }
}

初始化MainTabView时传入依赖：

MainTabView(
    viewModel: TabViewModel(),
    recipeViewModel: RecipeViewModel(),
    settingsViewModel: SettingsViewModel()
)

方式2：环境对象传递依赖 #

将子视图的ViewModel放入SwiftUI环境中，避免手动传递参数：

// 在App入口或父视图中注入环境对象
@main
struct RecipeApp: App {
    let recipeVM = RecipeViewModel()
    let settingsVM = SettingsViewModel()
    
    var body: some Scene {
        WindowGroup {
            MainTabView(viewModel: TabViewModel())
                .environmentObject(recipeVM)
                .environmentObject(settingsVM)
        }
    }
}

// 子视图中获取环境对象
struct RecipeListView: View {
    @EnvironmentObject var viewModel: RecipeViewModel
    
    var body: some View {
        // ...
    }
}

此时makeView无需额外参数，保持简洁：

extension TabType {
    @ViewBuilder
    func makeView() -> some View {
        switch self {
        case .recipes:
            RecipeListView()
        case .settings:
            SettingsView()
        }
    }
}

4. 简化协议与类型定义 #

如果不需要TabItem的多态实现，可以移除TabItemProviding协议，直接使用结构体简化代码：

struct TabItem {
    let id: UUID = UUID()
    let title: String
    let imageName: String
    let type: TabType
}

protocol TabViewModelProviding: ObservableObject {
    var tabs: [TabItem] { get }
}

另外，可让TabType自带默认的title和imageName，简化TabItem的创建：

extension TabType: CaseIterable {
    var title: String {
        switch self {
        case .recipes: "Recipes"
        case .settings: "Settings"
        }
    }
    
    var imageName: String {
        switch self {
        case .recipes: "wineglass.fill"
        case .settings: "gearshape.fill"
        }
    }
}

// TabViewModel中简化tabs初始化
class TabViewModel: TabViewModelProviding {
    @Published var tabs: [TabItem] = TabType.allCases.map {
        TabItem(title: $0.title, imageName: $0.imageName, type: $0)
    }
}

这样新增TabType的case时，会自动加入tabs数组，无需手动创建TabItem。

5. 避免泛型ViewModel的过度抽象 #

如果你的TabViewModelProviding协议仅定义了tabs属性，且没有多态需求，可以考虑移除泛型，直接使用具体的TabViewModel：

struct MainTabView: View {
    @ObservedObject var viewModel: TabViewModel
    
    // ... 其余代码不变
}

这样可以减少泛型带来的复杂度，除非你需要替换不同的ViewModel实现（如测试时用MockViewModel）。

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