Description

Many people have trouble getting the hang of dependency injection, at first. I think part of the problem is that it is actually so simple that we’re inclined to look for something more complicated. With that in mind, imagine that you’re writing an app that gives weather reports. You need a cloud-service (excuse the pun) to provide the data. At first, you go for a free weather report provider, but in future you’d like to integrate a weather service with better accuracy and more features. So like a good object-oriented developer, you make a WeatherClient protocol and back it initially with an implementation based on the free, online data provider.

Without Dependency Injection

It might look like this:

class WeatherReportController : UIViewController {
  let weatherClient = WeatherReportClient(key: myApiKey)
}
                

A problem with this approach is if you wanted to change to another weather client implementation you’d have to go and find all the places in your code that use the old one, and move them over to the new one. Each time, making sure to pass in the correct initialization parameters. A common approach is to have a centrally configured singleton:

class WeatherReportController : UIViewController {
  let weatherClient = WeatherReportClient.shared
}
                

Enter Dependency Injection:

Rather than seek out collaborators, they are provided externally.

class WeatherReportController : UIViewController {
  private(set) var weatherClient: WeatherReportProvider
  init(client: weatherClient) {
    self.weatherClient = client
  }
}
                

Is that it!?

More or less (dependency injection is, as they say, a $25 dollar term, for a five cent concept) but let‘s look at what happens when we start to apply this approach. If we continue to replace internally resolved dependencies with ones that are provided externally, we arrive at a module where the key actors, their lifecycles and their interactions are defined. This is known as the assembly or composition root.

Pulling construction of these components to the composition root lets your application tell an architectural story. When the key actors are pulled up into an assembly the app's configuration is no longer fragmented, duplicated or tightly coupled. We can have the benefits of singletons, without the drawbacks.

Benefits of Dependency Injection: