SwiftInjection
A dependency container for Swift
Setting up Dependencies
A Module file is where you define your dependencies. The goal is to abstract out all your dependencies in this file. The only class in your project that should know about concrete implementations should be the module class, the rest of the classes in your application should be using these implementations through interfaces.
You could have multiple module classes in order to organize your dependencies
public class AppModule: DIModule {
public func load(container: DIContainer) {
container.bind() { UserDefaults.standard() }
container.bind() { URLSession.shared() }
container.bind(type: HttpService.self) { HttpClient(baseUrl: "https://api.github.com", urlSession: $0)) }
container.bind(type: GithubService.self) { GithubHttpClient(httpService: $0) }
container.bind(type: AnalyticsTracker.self, named: GoogleAnalyticsTracker.analyticsIdentifier()) { GoogleAnalyticsTracker() }
container.bind(type: AnalyticsTracker.self, named: AmplitudeAnalyticsTracker.analyticsIdentifier()) { AmplitudeAnalyticsTracker() }
}
}
class AppDelegate: UIResponder, UIApplicationDelegate {
override init() {
super.init()
DIContainer.instance.addModule(AppModule())
}
}Binding Internal classes
avoid direct use of singletons to make your code more testable
container.bind() { URLSession.shared() }Binding classes as singleton
Instead of adding singleton logic to your classes simply bind them as singleton Note: Structs are not compatible with singleton pattern
// Bind class as singleton
bind(asSingleton: true) { Session() }
// Bind protocol to an implementation as singleton
bind(AnalyticsTracker.self, asSingleton: true) { GoogleAnalyticsTracker() }Bind Named Instances
In cases where you have multiple implementations for a single protocol you can use named binding to retrieve the correct instance
bind(AnalyticsTracker.self, named: "Google") { GoogleAnalyticsTraker() }
bind(AnalyticsTracker.self, named: "Amplitude") { AmplitudeAnalyticsTracker() }
// Inject expected instance
let googleAnalyticsTracker: AnalyticsTracker = inject(named: "Google")
let amplitudeAnalyticsTracker: AnalyticsTracker = inject(named: "Amplitude")
// Get all implementations for a given protocol (great for chain of responssibilities)
let trackers: [AnalyticsTracker] = injectAll()Property Injection
Only use property injection on root level, for anything else below the viewController use constructor injection
class ViewController: UIViewController {
let githubService: GithubService = inject() // Injects the implementation defined in module
let session = inject(Session.self) // injects the singleton instance
let analyticTrackers: [AnalyticsTracker] = injectAll() // Injects all implemetations of AnalyticsTracker
}Constructor Injection
Simpy pass dependencies through the intiializer and define binding in the module file
protocol GithubService { }
protocol HttpService { }
class GithubHttpClient: GithubService {
let httpService: HttpService
// Constructor injection
init(httpService: HttpService) {
self.httpService = httpService
}
}
class AppModule: DIModule {
func load(container: DIContainer) {
container.bind(type: URLSession.self) { URLSession.shared() }
container.bind(type: HttpService.self) { HttpClient(baseUrl: "https://api.github.com", urlSession: $0)) }
container.bind(type: GithubService.self) { GithubHttpClient(httpService: $0) }
}
}
class ViewController: UIViewController {
// Property Injection
// This will return an instance of GithubHttpClient with all depndencies as defined in module
let githubService: GithubService = inject()
}