Advanced Dependency Injection in .NET Core

---

5 January 2018

In the early posts of this series, we’ve already covered the basics of Dependency Injection (DI) in .NET Core, and its importance in promoting loose coupling and testability. However, DI in .NET Core has a lot more depth to explore, especially as your application grows in complexity.

Today, we’re going to dive deeper into advanced concepts of DI — covering service lifetimes (Scope, Singleton, and Transient), handling circular dependencies, and sharing best practices to make sure your DI setup is optimized for scalability, performance, and maintainability.

---

Service Lifetimes in .NET Core

One of the foundational aspects of Dependency Injection in .NET Core is understanding how service lifetimes work. In .NET Core, services are registered with one of the following three lifetimes:

1. Singleton:

• A Singleton service is created only once for the entire application. It is shared across the entire lifetime of the application, meaning that the same instance of the service is used for every request throughout the application’s life cycle. Singleton services are perfect for stateless services or services that hold expensive resources like database connections.
• Use Case: Caching, logging, configuration settings, etc.
• Example:

   public class SingletonService
   {
       private readonly string _id;

       public SingletonService()
       {
           _id = Guid.NewGuid().ToString();
       }

       public string GetId() => _id;
   }

Registering in Startup.cs:

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddSingleton<SingletonService>();
   }

2. Scoped:

• A Scoped service is created once per HTTP request or unit of work. It’s ideal for services that should maintain state across multiple method calls within the same request but should not persist between requests.
• Use Case: Database context (e.g., DbContext in Entity Framework), business logic that needs to be consistent per HTTP request.
• Example:

   public class ScopedService
   {
       public string ProcessData() => "Data processed for this request";
   }

Registering in Startup.cs:

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddScoped<ScopedService>();
   }

3. Transient:

• A Transient service is created each time it’s requested. It’s ideal for lightweight, stateless services. Transient services are particularly useful when you don’t need to share state across multiple requests or operations.
• Use Case: Lightweight utility classes, services that are used to perform a single task.
• Example:

   public class TransientService
   {
       public string PerformAction() => "Action performed for this operation";
   }

Registering in Startup.cs:

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddTransient<TransientService>();
   }

---

Handling Circular Dependencies

One of the common challenges when using Dependency Injection is circular dependencies, which occur when two or more services depend on each other. This can lead to issues like stack overflow or infinite loops if not handled correctly.

Consider the following situation:

• Class A depends on Class B, and Class B depends on Class A.

In such a case, the DI container might not know how to resolve these dependencies, leading to runtime exceptions. Thankfully, .NET Core’s DI container detects and prevents such circular dependencies automatically. However, sometimes you may have cases where indirect circular dependencies can still cause trouble.

Best Practices for Avoiding Circular Dependencies:

1. Refactor to Break the Cycle:

• If you find circular dependencies in your system, the first thing to do is to refactor the classes to eliminate them. This could involve breaking a service into multiple smaller services or abstracting one of the dependencies into an interface.

1. Use Lazy Initialization:

• In some cases, you can inject the dependencies lazily using Lazy<T>, which defers the creation of a service until it’s actually needed. This approach is particularly useful when working with complex dependencies.

   public class ClassA
   {
       private readonly Lazy<ClassB> _classB;

       public ClassA(Lazy<ClassB> classB)
       {
           _classB = classB;
       }

       public void DoSomething()
       {
           _classB.Value.PerformAction();
       }
   }

3. Use Factory Methods:

• Another approach to handling circular dependencies is to use factory methods, which allow for more control over the creation of dependent services. You can implement a factory pattern to create and resolve the dependencies dynamically.

---

Best Practices for Dependency Injection in .NET Core

Now that we’ve covered service lifetimes and how to handle circular dependencies, let’s look at some general best practices for working with Dependency Injection in .NET Core:

1. Use Constructor Injection:

• Prefer constructor injection over property or method injection. It makes dependencies explicit and easier to test, as well as ensures that the object is always created with valid dependencies.

1. Limit the Number of Dependencies:

• Avoid classes with too many dependencies (e.g., more than three). If you find yourself adding many dependencies to a class, consider whether the class is doing too much and needs to be refactored.

1. Register Dependencies with the Correct Lifetime:

• Ensure you’re using the appropriate service lifetime (Singleton, Scoped, Transient) for your services. Misusing service lifetimes can lead to performance bottlenecks, memory leaks, or excessive object creation.

1. Avoid Service Locator Pattern:

• Don’t use the service locator pattern to resolve dependencies manually in your code. It’s considered an anti-pattern in DI systems and can lead to hidden dependencies, which makes the code harder to test and maintain.

1. Keep the Startup Configuration Simple:

• Register your services in the ConfigureServices method of Startup.cs in a way that’s easy to understand and maintain. Group similar services together and keep configurations clean and modular.

---

Conclusion

Mastering Dependency Injection in .NET Core is crucial for building scalable, maintainable, and testable applications. By understanding and properly using service lifetimes (Singleton, Scoped, and Transient), handling circular dependencies, and following best practices, you ensure that your application is well-structured and prepared for growth.

As .NET Core continues to evolve, mastering DI will only become more important as you build more complex applications. In the next post, we’ll explore another critical concept of .NET Core: middleware. Stay tuned!

---