ASP.NET ConfigureServices

last modified April 3, 2025

In this article, we explore the ConfigureServices method in ASP.NET 8. This method is essential for configuring application services and dependencies.

ASP.NET is a cross-platform, high-performance framework for building modern web applications. ConfigureServices is where you register services for dependency injection.

Basic Definition

The ConfigureServices method in ASP.NET is part of the application startup process. It's called by the runtime to add services to the DI container.

Services registered in ConfigureServices become available throughout your application. This includes framework services and your own custom services.

ConfigureServices receives an IServiceCollection parameter which provides methods for service registration. The method is called before Configure.

ASP.NET ConfigureServices Example

The following example demonstrates a basic Web API with service configuration.

var builder = WebApplication.CreateBuilder(args);

// ConfigureServices equivalent in .NET 6+ minimal APIs
builder.Services.AddControllers();
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapControllers();
app.Run();

This shows the modern .NET 8 approach to service configuration. The builder.Services property replaces the traditional ConfigureServices.

We register controllers, a repository interface, Entity Framework DbContext, and Swagger documentation. Each service has a specific lifetime (Scoped here).

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public interface IProductRepository
{
    IEnumerable<Product> GetAll();
    Product GetById(int id);
    void Add(Product product);
}

public class ProductRepository : IProductRepository
{
    private readonly AppDbContext _context;

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

    public IEnumerable<Product> GetAll() => _context.Products.ToList();
    public Product GetById(int id) => _context.Products.Find(id);
    public void Add(Product product) => _context.Products.Add(product);
}

The repository pattern abstracts data access. The interface and implementation are registered in ConfigureServices. Entity Framework handles database operations.

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductRepository _repository;

    public ProductsController(IProductRepository repository)
    {
        _repository = repository;
    }

    [HttpGet]
    public ActionResult<IEnumerable<Product>> Get()
    {
        return Ok(_repository.GetAll());
    }

    [HttpGet("{id}")]
    public ActionResult<Product> Get(int id)
    {
        var product = _repository.GetById(id);
        if (product == null) return NotFound();
        return Ok(product);
    }
}

The controller demonstrates dependency injection in action. The repository is injected via constructor injection, enabled by ConfigureServices registration.

This example shows a complete flow: service registration, interface implementation, and consumption via DI. The pattern promotes loose coupling.

Source

Microsoft ASP.NET Dependency Injection Documentation

In this article, we have explored ConfigureServices in ASP.NET 8. This fundamental concept enables clean architecture through dependency injection.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all ASP.NET tutorials.