Access HttpContext in ASP.NET Core

HttpContext encapsulates all information about an individual HTTP request and response. An HttpContext instance is initialized when an HTTP request is received. The HttpContext instance is accessible by middleware and app frameworks such as Web API controllers, Razor Pages, SignalR, gRPC, and more.

For information about using HttpContext with a HTTP request and response, see Use HttpContext in ASP.NET Core.

Access HttpContext from Razor Pages

The Razor Pages PageModel exposes the PageModel.HttpContext property:

public class IndexModel : PageModel
{
    public void OnGet()
    {
        var message = HttpContext.Request.PathBase;

        // ...
    }
}

The same property can be used in the corresponding Razor Page View:

@page
@model IndexModel

@{
    var message = HttpContext.Request.PathBase;

    // ...
}

Access HttpContext from a Razor view in MVC

Razor views in the MVC pattern expose the HttpContext via the RazorPage.Context property on the view. The following example retrieves the current username in an intranet app using Windows Authentication:

@{
    var username = Context.User.Identity.Name;

    // ...
}

Access HttpContext from a controller

Controllers expose the ControllerBase.HttpContext property:

public class HomeController : Controller
{
    public IActionResult About()
    {
        var pathBase = HttpContext.Request.PathBase;

        // ...

        return View();
    }
}

Access HttpContext from minimal APIs

To use HttpContext from minimal APIs, add a HttpContext parameter:

app.MapGet("/", (HttpContext context) => context.Response.WriteAsync("Hello World"));

Access HttpContext from middleware

To use HttpContext from custom middleware components, use the HttpContext parameter passed into the Invoke or InvokeAsync method:

public class MyCustomMiddleware
{
    // ...

    public async Task InvokeAsync(HttpContext context)
    {
        // ...
    }
}

Access HttpContext from SignalR

To use HttpContext from SignalR, call the GetHttpContext method on Hub.Context:

public class MyHub : Hub
{
    public async Task SendMessage()
    {
        var httpContext = Context.GetHttpContext();

        // ...
    }
}

Access HttpContext from gRPC methods

To use HttpContext from gRPC methods, see Resolve HttpContext in gRPC methods.

Access HttpContext from custom components

For other framework and custom components that require access to HttpContext, the recommended approach is to register a dependency using the built-in Dependency Injection (DI) container. The DI container supplies the IHttpContextAccessor to any classes that declare it as a dependency in their constructors:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddHttpContextAccessor();
builder.Services.AddTransient<IUserRepository, UserRepository>();

In the following example:

• UserRepository declares its dependency on IHttpContextAccessor.
• The dependency is supplied when DI resolves the dependency chain and creates an instance of UserRepository.

public class UserRepository : IUserRepository
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public UserRepository(IHttpContextAccessor httpContextAccessor) =>
        _httpContextAccessor = httpContextAccessor;

    public void LogCurrentUser()
    {
        var username = _httpContextAccessor.HttpContext.User.Identity.Name;

        // ...
    }
}

HttpContext access from a background thread

HttpContext isn't thread-safe. Reading or writing properties of the HttpContext outside of processing a request can result in a NullReferenceException.

Note

If your app generates sporadic NullReferenceException errors, review parts of the code that start background processing or that continue processing after a request completes. Look for mistakes, such as defining a controller method as async void.

To safely do background work with HttpContext data:

• Copy the required data during request processing.
• Pass the copied data to a background task.
• Do not reference HttpContext data in parallel tasks. Extract the data needed from the context before starting the parallel tasks.

To avoid unsafe code, never pass HttpContext into a method that does background work. Pass the required data instead. In the following example, SendEmail calls SendEmailCoreAsync to start sending an email. The value of the X-Correlation-Id header is passed to SendEmailCoreAsync instead of the HttpContext. Code execution doesn't wait for SendEmailCoreAsync to complete:

public class EmailController : Controller
{
    public IActionResult SendEmail(string email)
    {
        var correlationId = HttpContext.Request.Headers["X-Correlation-Id"].ToString();

        _ = SendEmailCoreAsync(correlationId);

        return View();
    }

    private async Task SendEmailCoreAsync(string correlationId)
    {
        // ...
    }
}

IHttpContextAccessor/HttpContext in Razor components (Blazor)

IHttpContextAccessor generally should be avoided with interactive rendering because a valid HttpContext isn't always available.

IHttpContextAccessor can be used for components that are statically rendered on the server. However, we recommend avoiding it if possible.

HttpContext can be used as a cascading parameter only in statically-rendered root components for general tasks, such as inspecting and modifying headers or other properties in the App component (Components/App.razor). The value is always null for interactive rendering.

[CascadingParameter]
public HttpContext? HttpContext { get; set; }

For scenarios where the HttpContext is required in interactive components, we recommend flowing the data via persistent component state from the server. For more information, see ASP.NET Core server-side and Blazor Web App additional security scenarios.