What is dependency injection (DI) in ASP.NET Core?

Dependency Injection (DI) is a design pattern for inversion of control (IoC) that allows for creating loosely coupled code. In ASP.NET Core, DI is a built-in feature that makes it easy to manage dependencies between classes.

Main components of DI in ASP.NET Core:

1. Services: Objects that provide functionality (e.g., repository classes, logging services).
2. DI Container: An object responsible for resolving dependencies and creating service instances.
3. Service lifetimes: Define when and how service instances are created:
   • Transient: A new instance is created each time the service is requested.
   • Scoped: A single instance is created per request (for web applications — per HTTP request).
   • Singleton: A single instance is created on the first request and used throughout the application's lifetime.

Advantages of using DI:

• Loose coupling: Classes depend on abstractions (interfaces), not on concrete implementations.
• Testability: Easily replace real dependencies with mocks or stubs during unit testing.
• Extensibility: Easily replace service implementations without changing dependent code.
• Manageability of dependencies: The DI container manages the lifecycle and creation of instances.

Example of registering services in Startup.cs (or Program.cs in .NET 6+):

// In ConfigureServices method
public void ConfigureServices(IServiceCollection services)
{
    // Register a singleton service
    services.AddSingleton<ILogger, EmailLogger>();

    // Register a scoped service
    services.AddScoped<IDataRepository, SqlDataRepository>();

    // Register a transient service
    services.AddTransient<ITransientService, TransientService>();

    // Register controllers for dependency injection
    services.AddControllersWithViews();
}

Dependency injection in controller constructor:

```csharp
public class HomeController : Controller
{
    private readonly ILogger _logger;
    private readonly IDataRepository _repository;

    // ASP.NET Core DI automatically resolves and injects these dependencies
    public HomeController(ILogger logger, IDataRepository repository)
    {
        _logger = logger;
        _repository = repository;
    }

    // ... controller actions
}