What is dependency injection and how do you use it in .NET Core?

Dependency injection (DI) is a design pattern in which an object or component's dependencies (i.e., the objects it requires to function properly) are injected or provided from an external source rather than being created internally. In .NET Core, dependency injection is built into the framework and can be used to manage dependencies between objects and components.

Here's an example of how to use DI in a .NET Core application:

1. Define the dependencies: Start by defining the dependencies that your object or component requires. You can do this using constructor injection, property injection, or method injection. For example:

public class MyService
{
    private readonly ILogger<MyService> _logger;
    private readonly IEmailService _emailService;

    public MyService(ILogger<MyService> logger, IEmailService emailService)
    {
        _logger = logger;
        _emailService = emailService;
    }

    // ...
}


This example defines a MyService class that depends on a logger and an email service. The dependencies are defined using constructor injection.

2. Register the dependencies: Next, you need to register the dependencies with the .NET Core dependency injection container. You can do this in the ConfigureServices method of your Startup class. For example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddLogging();
    services.AddSingleton<IEmailService, EmailService>();
    services.AddTransient<MyService>();
}


This example registers the logger, email service, and MyService class with the dependency injection container. The AddLogging method adds the built-in logging services to the container, while the AddSingleton and AddTransient methods register the email service and MyService class as singleton and transient services, respectively.
 

3. Use the dependencies: Finally, you can use the dependencies in your application code by injecting them into your objects or components. For example:

public class HomeController : Controller
{
    private readonly MyService _myService;

    public HomeController(MyService myService)
    {
        _myService = myService;
    }

    public IActionResult Index()
    {
        _myService.DoSomething();
        return View();
    }
}


This example injects the MyService class into a controller class and uses it to perform some action in the Index method.

Overall, dependency injection is a powerful pattern that can help you manage dependencies between objects and components in your .NET Core applications, making your code more modular, testable, and maintainable.