Explain how to use dependency injection with DbContext in ASP.NET Core.

Using Dependency Injection (DI) with DbContext in ASP.NET Core allows the DbContext to be managed by ASP.NET Core’s DI container, making it easier to work with database operations throughout your application. DI ensures that the DbContext instances are correctly configured, automatically created, and disposed of as needed.

Here’s a step-by-step guide on setting up and using DI with DbContext in ASP.NET Core:

1. Configure Services in Startup.cs or Program.cs

In ASP.NET Core, configure the DbContext in the Startup.cs (for ASP.NET Core 3.1 and earlier) or Program.cs (for ASP.NET Core 5 and later) file. You’ll typically use the AddDbContext method to register your DbContext with the DI container, specifying the database provider and connection string.

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        // Register DbContext with SQL Server provider
        services.AddDbContext<AppDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
        
        // Add other services needed by the app
        services.AddControllers();
    }
}

• AddDbContext<AppDbContext> registers AppDbContext in the DI container, configuring it to use SQL Server with the connection string from appsettings.json.
• This setup tells ASP.NET Core to create and dispose of AppDbContext instances as needed for each request.

2. Define the DbContext Class

Create a custom DbContext class, typically containing DbSet properties for each table you want to work with.

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<Customer> Customers { get; set; }
    public DbSet<Order> Orders { get; set; }
}

• The AppDbContext constructor accepts DbContextOptions<AppDbContext> as a parameter, which is injected automatically when the DI container creates an instance of AppDbContext.

3. Inject the DbContext into a Controller or Service

You can now inject AppDbContext into any controller, service, or class that’s registered in the DI container. ASP.NET Core will automatically resolve the dependency and provide a properly configured DbContext instance.

public class CustomersController : ControllerBase
{
    private readonly AppDbContext _context;

    public CustomersController(AppDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<Customer>>> GetCustomers()
    {
        return await _context.Customers.ToListAsync();
    }
}

• In the CustomersController constructor, AppDbContext is injected by ASP.NET Core’s DI container.
• The _context variable can then be used to perform database operations.

4. Using Scoped Lifetime with DbContext

DbContext is registered with a scoped lifetime by default in AddDbContext. This means:

• A new DbContext instance is created for each HTTP request, ensuring thread safety and isolation of requests.
• The instance is disposed of at the end of the request.

Note: The scoped lifetime is suitable for web applications, as it ensures each request operates in isolation. For background services or single-threaded operations, consider using AddDbContextFactory.

5. Registering DbContext for Background Services

If you have a background service where you need to inject DbContext, you can use AddDbContextFactory for a more flexible and controlled instance creation, especially useful in non-HTTP scenarios.

services.AddDbContextFactory<AppDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

In a background service, you would then inject IDbContextFactory<AppDbContext> and create AppDbContext instances as needed.

public class BackgroundTask : IHostedService
{
    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;

    public BackgroundTask(IDbContextFactory<AppDbContext> dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }

    public async Task DoWorkAsync()
    {
        using var context = _dbContextFactory.CreateDbContext();
        // Perform database operations
    }
}

Summary

Using DI with DbContext in ASP.NET Core promotes efficient resource management, thread safety, and separation of concerns. It allows controllers and services to automatically receive a configured DbContext instance, enabling a straightforward approach to database operations in a multi-layered architecture. The DI container takes care of creating and disposing of DbContext instances, so developers can focus on implementing application logic.