1

我正在使用 Swinject 进行依赖注入。我创建了一个具有容器共享实例的 DependencyManager。

internal class DependencyManager {
private static let sharedInstance = DependencyManager()

private var assembler: Assembler
private let container: Container

class func getResolver() -> Resolver {
    return self.sharedInstance.assembler.resolver
}

class func getContainer() -> Container {
    return self.sharedInstance.container
}

private init() {
    self.container = Container()
    let assembler = Assembler([
        LoginFactory()
        ])
    self.assembler = assembler
}

}

LoginFactory 类实现Assembly

internal class LoginFactory: Assembly {
func assemble(container: Container) {
    container.register(LSViewModel.self) { res in
        return LSViewModel()
    }
    container.register(LSCoordinator.self, factory: { res in
        let lsc = LSCoordinator(window: AppDelegate.mainWindow!)
        lsc.viewModel = res.resolve(LSViewModel.self)
        return lsc
    })
}

}

我阅读了大会文档，其中说它更适合用于组织 - https://github.com/Swinject/Swinject/blob/master/Documentation/Assembler.md。如果我没有使用 Assembly，那么我会使用类似的命令

        DependencyManager.getContainer().register(LSViewModel.self) { _ in LSViewModel() }
    DependencyManager.getContainer().register(LSCoordinator.self, factory: { (res) in
        let lsc = LSCoordinator(window: AppDelegate.mainWindow!)
        lsc.viewModel = res.resolve(LSViewModel.self)
        return lsc
    })
    let lsCoordinator: LSCoordinator = DependencyManager.getContainer().resolve(LSCoordinator.self)!

两种实现都按预期工作，没有任何崩溃。我想知道为什么组装甚至是一个优势？我正在做同样的事情而不使用 Assembly 而没有开销。

4

1 回答 1

2

一旦项目变得足够大，使用组织代码的好处Assembly将开始超过“无开销”系统。保持代码模块化和可重用的一种方法是（除其他外）：

  1. 分别保留不同功能的 DI 代码
  2. 功能不知道最终应用程序是如何组合在一起的（例如DependencyManager）

IMO 1. 非常直观。2. 较少，但在使用程序集时是免费的，并为您提供了很大的灵活性 - 例如，您可能希望在多个应用程序中重用该功能（例如网络）。

使用程序集你会有类似的东西

let assembler = Assembler([
    LoginAssembly(), // each assembly contains DI code for one feature
    HomepageAssembly(),
    UserProfileAssembly(),
    // ...
])

而使用直观的方法可能会变得非常混乱。

于 2018-02-14T10:22:35.480 回答