What is Dependency Injection used for?

Dependency Injection (DI) is used to manage dependencies between components of an application.

Main goals of DI:

• Reducing coupling: Components do not create their dependencies directly but receive them from outside. This makes components more independent and easier to reuse.
• Improving testability: Isolated testing of individual components becomes easier, as mock objects or stubs can be substituted for real dependencies.
• Increasing flexibility and extensibility: It is easier to replace dependency implementations without changing the code of the components that use them.
• Simplifying configuration: Dependencies can be configured centrally, for example, during application startup.

Main approaches to DI:

• Constructor Injection: Dependencies are passed as constructor parameters. This is the most common and recommended approach, as it guarantees the presence of all necessary dependencies when creating an object.

  // Dependency
  public interface ILogger
  {
      void Log(string message);
  }
  
  // Component with dependency
  public class MyService
  {
      private readonly ILogger _logger;
  
      public MyService(ILogger logger) // Injection via constructor
      {
          _logger = logger;
      }
  
      public void DoSomething()
      {
          _logger.Log("Doing something.");
      }
  }
  

• Property Injection: Dependencies are set through public properties. Less preferred, as it does not guarantee that the dependency will be set.

  public class MyService
  {
      public ILogger Logger { get; set; } // Injection via property
  
      public void DoSomething()
      {
          Logger?.Log("Doing something."); // Null check
      }
  }
  

• Method Injection: Dependencies are passed as method parameters. Used when the dependency is only needed for a specific method.

  public class MyService
  {
      public void DoSomething(ILogger logger) // Injection via method
      {
          logger.Log("Doing something.");
      }
  }
  

DI is often implemented using a DI container (Inversion of Control Container), which manages the lifecycle of objects and resolves their dependencies. Popular DI containers in .NET include: Microsoft.Extensions.DependencyInjection (built-in), Autofac, Ninject, Castle Windsor.

DI is a key principle for building maintainable, testable, and extensible applications.