Accedere a HttpContext in ASP.NET Core

Il HttpContext incapsula tutte le informazioni su un singolo HTTP request e response. Un'istanza HttpContext viene inizializzata quando viene ricevuta una richiesta HTTP. L'istanza HttpContext è accessibile dal middleware e dai framework dell'app, come i controller dell'API Web, le Razor pagine, SignalR, gRPC e altro.

Per informazioni sull'uso di HttpContext con una richiesta e una risposta HTTP, vedere Use HttpContext in ASP.NET Core.

Accedere a HttpContext dalle Razor pagine

Le Razor Pages PageModel espongono la HttpContext proprietà:

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

        // ...
    }
}

È possibile utilizzare la stessa proprietà nella visualizzazione della pagina corrispondente Razor.

@page
@model IndexModel

@{
    var message = HttpContext.Request.PathBase;
    
    // ...
}

Accedere a HttpContext da una Razor visualizzazione in MVC

Razor le visualizzazioni nel modello MVC espongono tramite HttpContext la Context proprietà nella vista. L'esempio seguente recupera il nome utente corrente in un'app Intranet usando Windows Authentication:

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

Accedere a HttpContext da un controller

I controller espongono la HttpContext proprietà :

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

        // ...

        return View();
    }
}

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

Accedere a HttpContext dal middleware

Per utilizzare HttpContext dai componenti middleware personalizzati, passa il parametro HttpContext nel metodo Invoke o InvokeAsync.

public class MyCustomMiddleware
{
    // ...

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

Accedere a HttpContext da SignalR

Per usare HttpContext da SignalR, chiamare il GetHttpContext su Context:

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

        // ...
    }
}

Accedere a HttpContext dai metodi gRPC

Per usare HttpContext dai metodi di gRPC, vedere Risolvere HttpContext nei metodi gRPC.

Accedere a HttpContext da componenti personalizzati

Per altri framework e componenti personalizzati che richiedono l'accesso a HttpContext, l'approccio consigliato consiste nel registrare una dipendenza usando il contenitore di inserimento delle dipendenze predefinito. Il contenitore di inserimento delle dipendenze fornisce a IHttpContextAccessor tutte le classi che la dichiarano come dipendenza nei relativi costruttori:

var builder = WebApplication.CreateBuilder(args);

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

public void ConfigureServices(IServiceCollection services)
{
     services.AddControllersWithViews();
     services.AddHttpContextAccessor();
     services.AddTransient<IUserRepository, UserRepository>();
}

Nell'esempio seguente :

• L'istanza UserRepository dichiara la relativa dipendenza da IHttpContextAccessor.
• La dipendenza viene fornita quando la Dependency Injection (DI) risolve la catena di dipendenze e crea un'istanza di 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;

        // ...
    }
}

public class UserRepository : IUserRepository
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public UserRepository(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

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

Accedere a HttpContext da un thread in background

HttpContext non è thread-safe. La lettura o la scrittura di proprietà del HttpContext al di fuori dell'elaborazione di una richiesta può generare un errore NullReferenceException.

Per eseguire in modo sicuro operazioni in background con i HttpContext dati:

• Copiare i dati necessari durante l'elaborazione della richiesta.
• Passare i dati copiati a un'attività in background.
• Non fare riferimento ai HttpContext dati nelle attività parallele. Estrarre i dati necessari dal contesto prima di avviare le attività parallele.

Per evitare codice non sicuro, non passare HttpContext mai a un metodo che esegue il lavoro in background. Passare invece i dati necessari.

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)
    {
        // ...
    }
}

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

        _ = SendEmailCore(correlationId);

        return View();
    }

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

Accedere a IHttpContextAccessor o HttpContext all'interno dei Razor componenti (Blazor)

Per accedere al IHttpContextAccessor o al HttpContext nei componenti Razor (app Blazor), consulta IHttpContextAccessor/HttpContext nelle app ASP.NET Core Blazor.

Contenuti correlati

• Use HttpContext in ASP.NET Core
• Razor Architettura e concetti delle pagine in ASP.NET Core
• Servizi gRPC con ASP.NET Core