This chapter delved into Dependency Injection, understanding its crucial role in crafting adaptable systems. We learned how DI applies the Inversion of Control principle, shifting dependency creation from the objects to the composition root. We explored the IoC container’s role in object management, service resolution and injection, and dependency lifetime management. We tackled the Control Freak anti-pattern, advocating for dependency injection over using the new keyword.We revisited the Strategy pattern and explored how to use it with Dependency Injection to compose complex object trees. We learned about the principle of composition over inheritance, which encourages us to inject dependencies into the classes instead of relying on base class features and inheritance. We explored different ways of injecting dependencies into objects, including constructor injection, property injection, and method injection.We learned that a guard clause is a condition that must be met before a method is executed, often used to prevent null dependencies. We explored how to implement guard clauses. We also discussed the importance of adding guard clauses, as nullable reference type checks offer no guarantee at runtime.We revisited the Singleton pattern and how to replace it with a lifetime. We explored two examples utilizing the singleton lifetime to provide application-level features.We delved into the Service Locator pattern, often considered an anti-pattern, as it can create hidden coupling and revert the Inversion of Control principle. We learned that avoiding using the Service Locator pattern is generally best. We explored how to implement the Service Locator pattern and discussed the potential issues that could arise. We revisited the Factory pattern and learned how to build a simple, DI-oriented factory that replaces the object creation logic of the IoC container.Here are the key takeaways from this substantial chapter:

• Dependency Injection is a technique applying the Inversion of Control principle for effective dependency management and lifetime control.
• An IoC container resolves and manages dependencies, offering varying control over object behavior.
• We can categorize dependencies into stable and volatile, the latter justifying DI.
• The lifetime of a service is Transient, Scoped, or Singleton.
• Dependency injection allows us to avoid the Control Freak anti-pattern and stop creating objects with the new keyword, improving flexibility and testability.
• The Service Locator pattern often creates hidden coupling and should be avoided but in the composition root.
• The composition root is where we register our service bindings with the IoC container; in the Program.cs file.
• Composing objects using the Strategy pattern alongside constructor injection facilitates handling complex object trees, emphasizing the principle of composition over inheritance.
• On top of constructor injection, there’s also method injection and property injection, which are less supported. It is best to prioritize constructor injection over the others.
• Guard clauses safeguard method execution from unmet conditions.
• It is better to avoid the Singleton pattern in favor of binding a class and an interface with a singleton lifetime in the container.
• The Factory pattern is ideal for creating objects with complex instantiation logic.
• Moving code around doesn’t eliminate dependencies or coupling; it’s important not to overengineer solutions.

In subsequent sections, we explore tools that add functionalities to the default built-in container. Meanwhile, we explore options, settings, and configurations in the next chapter. These ASP.NET Core patterns aim to make our lives easier when managing such common problems.