Accesso HttpContext in ASP.NET Core

HttpContext incapsula tutte le informazioni su una singola richiesta e risposta HTTP. Un'istanza HttpContext viene inizializzata quando viene ricevuta una richiesta HTTP. L'istanza HttpContext è accessibile dal middleware e dai framework dell'app, ad esempio controller API Web, Razor Pagine, SignalR, gRPC e altro ancora.

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

Accesso HttpContext da Razor pagine

Pages Razor PageModel espone la PageModel.HttpContext proprietà :

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

        // ...
    }
}

La stessa proprietà può essere usata nella visualizzazione pagina corrispondente Razor :

@page
@model IndexModel

@{
    var message = HttpContext.Request.PathBase;

    // ...
}

Accesso HttpContext da una Razor visualizzazione in MVC

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

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

    // ...
}

Accesso HttpContext da un controller

I controller espongono la ControllerBase.HttpContext proprietà :

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

        // ...

        return View();
    }
}

Accesso HttpContext da API minime

Per usare HttpContext da API minime, aggiungere un HttpContext parametro:

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

Accesso HttpContext dal middleware

Per usare HttpContext da componenti middleware personalizzati, usare il HttpContext parametro passato nel Invoke metodo o InvokeAsync :

public class MyCustomMiddleware
{
    // ...

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

Accesso HttpContext da SignalR

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

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

        // ...
    }
}

Accesso HttpContext dai metodi gRPC

Per usare HttpContext i metodi gRPC, vedere Risolvere HttpContext nei metodi gRPC.

Accesso 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>();

Nell'esempio seguente :

• UserRepository dichiara la dipendenza da IHttpContextAccessor.
• La dipendenza viene fornita quando l'inserimento delle dipendenze 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;

        // ...
    }
}

HttpContext accesso da un thread in background

HttpContext non è thread-safe. La lettura o scrittura delle proprietà HttpContext di fuori dell'elaborazione di una richiesta può provocare un'eccezione NullReferenceException.

Nota

Se l'app genera errori sporadici NullReferenceException , esaminare parti del codice che avviano l'elaborazione in background o che continuano l'elaborazione dopo il completamento di una richiesta. Cercare errori, ad esempio la definizione di un metodo controller come async void.

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. Nell'esempio seguente viene SendEmail chiamato SendEmailCoreAsync per iniziare a inviare un messaggio di posta elettronica. Il valore dell'intestazione X-Correlation-Id viene passato a anziché a SendEmailCoreAsync HttpContext. L'esecuzione del codice non attende SendEmailCoreAsync il completamento:

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 nei Razor componenti (Blazor)

IHttpContextAccessor è necessario evitare il rendering interattivo perché non è disponibile un valore valido HttpContext .

IHttpContextAccessor può essere usato per i componenti di cui viene eseguito il rendering statico nel server. Tuttavia, è consigliabile evitarlo, se possibile.

HttpContext può essere usato come parametro a catena solo nei componenti radice sottoposti a rendering statico per attività generali, ad esempio l'ispezione e la modifica di intestazioni o altre proprietà nel App componente (Components/App.razor). Il valore è sempre null per il rendering interattivo.

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

Per gli scenari in cui HttpContext è necessario nei componenti interattivi, è consigliabile fluire i dati tramite lo stato del componente persistente dal server. Per altre informazioni, vedere ASP.NET core server-side e Blazor Web App altri scenari di sicurezza.