Modern Approaches to Configuration Access During Startup in ASP.NET Core 6+

Introduction

With the release of ASP.NET Core 6, Microsoft introduced a simplified application startup model that removes the traditional Startup.cs class. This change aims to reduce boilerplate code and enhance development efficiency. However, many developers are confused about how to access configuration and environment information within this new startup model. This article clarifies the correct approaches in ASP.NET Core 6+ through detailed code examples and thorough analysis.

Traditional Startup Model Overview

In ASP.NET Core 5 and earlier versions, application startup logic was typically defined in the Startup.cs file. Developers obtained IConfiguration and IHostEnvironment instances via constructor injection:

public class Startup 
{
    private readonly IHostEnvironment environment;
    private readonly IConfiguration config;

    public Startup(IConfiguration configuration, IHostEnvironment environment) 
    {
        this.config = configuration;
        this.environment = environment;
    }

    public void ConfigureServices(IServiceCollection services) 
    {
        // Service configuration logic
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env) 
    {
        // Middleware configuration logic
    }
}

While this model was fully functional, it required developers to write considerable boilerplate code. As application complexity grew, the Startup class often became bloated and difficult to maintain.

The New Startup Model

ASP.NET Core 6 introduced a simplified startup model based on top-level statements. The new Program.cs file uses the WebApplication.CreateBuilder(args) method to create an application builder:

var builder = WebApplication.CreateBuilder(args);

This builder object provides direct access to configuration and environment information, eliminating the need for constructor injection.

Configuration Access Methods

During the build phase, you can access the configuration manager via the builder.Configuration property:

var builder = WebApplication.CreateBuilder(args);

// Access configuration manager
ConfigurationManager configuration = builder.Configuration;

// Access environment information
IWebHostEnvironment environment = builder.Environment;

The ConfigurationManager implements the IConfiguration interface, offering full configuration access capabilities. Developers can use familiar methods such as GetConnectionString(), GetSection(), and others to read configuration values.

Practical Application Example

The following example demonstrates how to use configuration information during service registration:

var builder = WebApplication.CreateBuilder(args);

// Add Razor Pages services
builder.Services.AddRazorPages();

// Correctly register DbContext using configuration
builder.Services.AddDbContext<FestifyContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Festify")));

In this example, we directly use builder.Configuration.GetConnectionString("Festify") to retrieve the database connection string, avoiding the complexity of injecting configuration objects required in previous versions.

Post-Build Configuration Access

After the application is built, you can still access configuration and environment information through the WebApplication instance:

var app = builder.Build();

// Access configuration after build
IConfiguration configuration = app.Configuration;
IWebHostEnvironment environment = app.Environment;

This access method is particularly useful when configuring middleware based on the environment. For example, enabling detailed error pages in development and using custom error handling in production:

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

Configuration Sources and Priority

ASP.NET Core 6+ maintains the same configuration source loading order as previous versions:

1. appsettings.json
2. appsettings.{Environment}.json
3. User secrets (development environment only)
4. Environment variables
5. Command-line arguments

This configuration source design ensures flexibility and security, allowing developers to use different configuration values across various environments.

Migration Guidelines

For projects migrating from older versions, we recommend following these steps:

1. Move service registration logic from Startup.cs to the builder.Services section in Program.cs
2. Use builder.Configuration to replace configuration instances previously obtained via constructor injection
3. Move middleware configuration logic to after app.Build()
4. Remove the Startup.cs file and related references

Best Practices

When using the new startup model, we recommend adhering to the following best practices:

• Define all configuration-related variables at the top of the Program.cs file
• Use builder.Configuration for direct configuration access, avoiding unnecessary variable storage
• Leverage environment-specific configuration files to manage settings across different environments
• Consider creating extension methods to maintain Program.cs simplicity when complex configuration logic is required

Conclusion

The new startup model in ASP.NET Core 6+ provides a more concise and intuitive approach to configuration access through WebApplicationBuilder and WebApplication. Developers can directly access required information via the builder.Configuration and builder.Environment properties, eliminating complex dependency injection setup. This improvement not only reduces boilerplate code but also enhances code readability and maintainability. As the .NET ecosystem continues to evolve, mastering these new programming patterns is crucial for maintaining technical competitiveness.