SwiftUI中是否存在等效于C# CastleWindsor的依赖注入方式以共享GameSettings实例？

作为有C# Castle Windsor使用经验的开发者，我完全懂你想要在SwiftUI里实现类似依赖注入、共享GameSettings实例的需求。在Swift生态里，我们有几种成熟的方案能搞定这个问题，下面给你详细拆解：

这是Apple专门为SwiftUI设计的跨视图层级共享ObservableObject的方式，相当于内置的“全局共享容器”，非常适合你的场景：

步骤1：在App入口注入共享实例 #

首先在你的App主结构体里创建GameSettings的单例，并注入到整个视图环境中：

@main
struct YourTabApp: App {
    // 创建全局唯一的GameSettings实例
    private let sharedGameSettings = GameSettings()
    
    var body: some Scene {
        WindowGroup {
            Tab_View()
                .environmentObject(sharedGameSettings) // 把实例注入到环境
        }
    }
}

步骤2：在View中获取并传递给ViewModel #

修改你的Main1_View，通过@EnvironmentObject获取共享实例，再传给ViewModel：

struct Main1_View: View {
    @EnvironmentObject var gameSettings: GameSettings
    @ObservedObject var viewModel: Main1_ViewModel
    
    init() {
        // 把共享的settings注入到ViewModel
        self.viewModel = Main1_ViewModel(settings: gameSettings)
    }
    
    var body: some View {
        VStack(spacing: 0) {
            // 你的视图代码
        }
    }
}

步骤3：调整ViewModel的初始化 #

把ViewModel改成通过构造器接收GameSettings，不用再内部创建：

class Main1_ViewModel: ObservableObject {
    let settings: GameSettings
    // 如果需要监听settings的变化，这里可以保留@ObservedObject
    // @ObservedObject var settings: GameSettings
    
    init(settings: GameSettings) {
        self.settings = settings
    }
    
    func Randomise(){
        dataSource = settings.selectedFramework;
    }
}

这个方案的好处是完全原生，不需要额外依赖，而且能自动在视图层级中传递实例，非常适合SwiftUI项目。

如果你更习惯C#里那种“显式传递依赖”的风格，手动构造器注入是个更可控的选择，而且方便单元测试时Mock依赖：

步骤1：在Tab视图中创建共享实例 #

在Tab_View层级创建GameSettings的单例，然后传递给每个子View的ViewModel：

struct Tab_View: View {
    // 在这里创建全局共享的实例
    private let sharedGameSettings = GameSettings()
    
    var body: some View {
        TabView{
            Main1_View(
                viewModel: Main1_ViewModel(settings: sharedGameSettings)
            )
            .tabItem {
                Text("Blah 1")
                Image("TabBar1")
            }
            
            Main2_View(
                viewModel: Main2_ViewModel(settings: sharedGameSettings)
            )
            .tabItem {
                Text("Blah 2")
                Image("TabBar2")
            }
        }
    }
}

步骤2：调整View的初始化 #

让Main1_View直接接收外部传入的ViewModel，不再内部创建：

struct Main1_View: View {
    @ObservedObject var viewModel: Main1_ViewModel
    
    // 外部传入已经注入依赖的ViewModel
    init(viewModel: Main1_ViewModel) {
        self.viewModel = viewModel
    }
    
    var body: some View {
        VStack(spacing: 0) {
            // 你的视图代码
        }
    }
}

这种方式的优势是依赖关系完全透明，没有“隐式依赖”，单元测试时可以轻松传入Mock的GameSettings实例。

如果你习惯了用容器来管理所有依赖，可以使用Swift社区的第三方DI库，比如Swinject（类似Castle Windsor的功能）。核心思路是注册依赖的单例，然后在需要的地方从容器中解析：

示例代码： #

// 1. 创建全局DI容器
let container = Container()

// 2. 注册GameSettings为单例（容器级作用域）
container.register(GameSettings.self) { _ in GameSettings() }
    .inObjectScope(.container)

// 3. 在需要的地方解析实例
let gameSettings = container.resolve(GameSettings.self)!
let viewModel = Main1_ViewModel(settings: gameSettings)

你也可以把容器注入到SwiftUI的Environment中，这样就能在任意视图里获取容器并解析依赖，和EnvironmentObject的使用方式类似。

总结一下：如果是纯SwiftUI项目，优先推荐EnvironmentObject或者构造器注入，前者快捷原生，后者可控易测；如果习惯了容器化DI的工作流，第三方库能帮你实现类似Castle Windsor的体验。

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