# What Is the Role of IApplicationBuilder in ASP.NET Core Startup?

> Discover the role of IApplicationBuilder in ASP.NET Core startup. Learn how it helps assemble the HTTP request pipeline and register middleware for efficient request handling.

- Repository: [.NET Platform/aspnetcore](https://github.com/dotnet/aspnetcore)
- Tags: internals
- Published: 2026-07-13

---

**IApplicationBuilder is the central interface used to assemble the HTTP request pipeline during ASP.NET Core startup, enabling developers to register middleware components that process incoming requests through a chain of delegates.**

During ASP.NET Core application startup, the `Configure` method in your `Startup` class receives an instance of `IApplicationBuilder` to construct the middleware pipeline. This interface, defined in the `dotnet/aspnetcore` repository, serves as the primary mechanism for defining how HTTP requests are handled, authenticated, routed, and responded to throughout your application's lifetime.

## Core Responsibilities of IApplicationBuilder

### Chaining Middleware Components

The builder maintains an internal list of middleware delegates. Each call to `Use...` extension methods (such as `app.UseRouting()`) appends a component to this chain. According to the source code in [`src/Http/Http.Abstractions/src/IApplicationBuilder.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http.Abstractions/src/IApplicationBuilder.cs), the order of registration determines the exact execution sequence for every incoming request.

### Exposing the Dependency Injection Container

`IApplicationBuilder` exposes the `ApplicationServices` property, which holds a reference to the app's `IServiceProvider`. This allows middleware to resolve services from the DI container, as implemented in [`src/Http/Http.Abstractions/src/ApplicationBuilder.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http.Abstractions/src/ApplicationBuilder.cs).

### Sharing Data via Properties

The `Properties` dictionary provides a mechanism for middleware to share data across the pipeline. This per-request-lifetime dictionary stores flags, configuration objects, and other state that components need to access during request processing.

### Creating Sub-Pipelines

The `New()` method generates a fresh `IApplicationBuilder` instance for building isolated pipeline branches. This is useful for conditional routing or feature toggles, allowing you to construct sub-pipelines that can be integrated back into the main request flow.

## How IApplicationBuilder Works During Startup

The typical flow follows these steps:

1. The host creates an `ApplicationBuilder` instance (the default implementation of `IApplicationBuilder`).
2. It invokes `Startup.Configure(IApplicationBuilder app, …)` with this instance.
3. Inside `Configure`, you add middleware by calling extension methods on the builder.
4. When the application runs, the framework composes the registered middleware into a single `RequestDelegate` that processes every request.

## Building the Request Pipeline in Practice

The following example from the `dotnet/aspnetcore` source demonstrates a standard `Configure` method:

```csharp
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

```

Each extension method (defined in files like [`src/Routing/Routing/src/UseRoutingExtensions.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Routing/Routing/src/UseRoutingExtensions.cs)) operates on the `IApplicationBuilder` to add specific functionality to the pipeline.

## Creating Sub-Pipelines with New()

For advanced scenarios such as API-specific logging or conditional branches, you can create sub-pipelines using `New()`:

```csharp
public void Configure(IApplicationBuilder app)
{
    app.UseRouting();

    app.Map("/api", apiApp =>
    {
        var branch = apiApp.New();
        
        branch.UseMiddleware<ApiLoggingMiddleware>();
        branch.UseEndpoints(endpoints => endpoints.MapControllers());
        
        apiApp.Use(branch.Build());
    });

    app.UseEndpoints(endpoints => endpoints.MapRazorPages());
}

```

This pattern, supported by the implementation in [`src/Http/Http.Abstractions/src/ApplicationBuilder.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http.Abstractions/src/ApplicationBuilder.cs), allows you to isolate middleware for specific route prefixes without affecting the main application pipeline.

## Summary

- `IApplicationBuilder` defines the contract for assembling the HTTP request pipeline in the `dotnet/aspnetcore` repository.
- The `Configure` method receives this builder to register middleware via `Use...` extension methods.
- It provides access to `ApplicationServices` for dependency injection and `Properties` for cross-middleware data sharing.
- The `New()` method enables creation of sub-pipelines for conditional request processing.
- Middleware order is determined by registration sequence, with the final pipeline composed into a `RequestDelegate`.

## Frequently Asked Questions

### What is the difference between IApplicationBuilder and IServiceCollection?

`IServiceCollection` is used in `ConfigureServices` to register application services and dependencies for dependency injection. `IApplicationBuilder` is used in `Configure` to assemble the middleware pipeline that processes HTTP requests. The former configures the service container; the latter configures the request handling pipeline.

### When should I use ApplicationBuilder.New()?

Use `New()` when you need to create a sub-pipeline for a specific branch of your application, such as applying different middleware to API routes versus web pages. This method creates a fresh builder instance that you can configure independently before integrating it back into the main pipeline via `Build()`.

### How does middleware ordering affect request processing?

Middleware executes in the order it is registered on `IApplicationBuilder`. Components added first see the request first on the incoming path and last on the outgoing response path. This ordering is critical for functionality like authentication, which must typically run before authorization and endpoint routing.

### Where is IApplicationBuilder defined in the ASP.NET Core source?

The interface is defined in [`src/Http/Http.Abstractions/src/IApplicationBuilder.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http.Abstractions/src/IApplicationBuilder.cs), with the default implementation `ApplicationBuilder` located in [`src/Http/Http.Abstractions/src/ApplicationBuilder.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/Http.Abstractions/src/ApplicationBuilder.cs) within the `dotnet/aspnetcore` repository.