Zugreifen auf HttpContext in ASP.NET Core

HttpContext kapselt sämtliche Informationen zu einer einzelnen HTTP-Anforderung und -Antwort. Eine HttpContext-Instanz wird initialisiert, wenn eine HTTP-Anforderung empfangen wird. Auf die HttpContext-Instanz kann von Middleware und App-Frameworks wie Web-API-Controllern, Razor Pages, SignalR, gRPC und mehr zugegriffen werden.

Informationen zur Verwendung von HttpContext mit einer HTTP-Anforderung und -Antwort finden Sie unter Verwenden von HttpContext in ASP.NET Core.

Zugreifen auf HttpContext aus Razor Pages

Das Razor von PageModel Pages stellt die PageModel.HttpContext-Eigenschaft zur Verfügung:

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

        // ...
    }
}

Dieselbe Eigenschaft kann in der entsprechenden Razor-Seitenansicht verwendet werden:

@page
@model IndexModel

@{
    var message = HttpContext.Request.PathBase;

    // ...
}

Zugreifen auf HttpContext aus einer Razor-Ansicht in MVC

Razor-Ansichten im MVC-Muster machen HttpContext über die RazorPage.Context-Eigenschaft in der Ansicht verfügbar. Im folgenden Beispiel wird der aktuelle Benutzername in einer Intranet-App abgerufen, die die Windows-Authentifizierung verwendet:

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

    // ...
}

Zugreifen auf HttpContext aus einem Controller

Controller machen die ControllerBase.HttpContext-Eigenschaft verfügbar:

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

        // ...

        return View();
    }
}

Zugreifen auf HttpContext aus minimalen APIs

Um HttpContext aus minimalen APIs zu verwenden, fügen Sie den Parameter HttpContext hinzu:

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

Zugreifen auf HttpContext aus Middleware

Um HttpContext aus benutzerdefinierten Middlewarekomponenten nutzen zu können, verwenden Sie den Parameter HttpContext, der an die Methode Invoke oder InvokeAsync übergeben wird:

public class MyCustomMiddleware
{
    // ...

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

Zugreifen auf HttpContext aus SignalR

Um HttpContext aus SignalR zu verwenden, rufen Sie die Methode GetHttpContext für Hub.Context auf:

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

        // ...
    }
}

Zugreifen auf HttpContext aus gRPC-Methoden

Informationen zum Verwenden von HttpContext aus gRPC-Methoden finden Sie unter Auflösen von HttpContext in gRPC-Methoden.

Zugreifen auf HttpContext aus benutzerdefinierten Komponenten

Für andere Framework- und benutzerdefinierte Komponenten, die Zugriff auf HttpContext erfordern, wird empfohlen, eine Abhängigkeit mithilfe des integrierten Abhängigkeitsinjektionscontainers zu registrieren. Der Abhängigkeitsinjektionscontainer stellt IHttpContextAccessor allen Klassen zur Verfügung, die ihn in ihren Konstruktoren als Abhängigkeit deklarieren:

var builder = WebApplication.CreateBuilder(args);

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

Im folgenden Beispiel:

• UserRepository deklariert seine Abhängigkeit von IHttpContextAccessor.
• Die Abhängigkeit wird bereitgestellt, wenn die Abhängigkeitsinjektion die Abhängigkeitskette auflöst und eine UserRepository-Instanz erstellt.

public class UserRepository : IUserRepository
{
    private readonly IHttpContextAccessor _httpContextAccessor;

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

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

        // ...
    }
}

Zugreifen auf HttpContext aus einem Hintergrundthread

HttpContext ist nicht threadsicher. Eigenschaften von HttpContext außerhalb der Verarbeitung einer Anforderung zu lesen oder zu schreiben kann zu einer NullReferenceException führen.

Hinweis

Wenn Ihre App sporadische NullReferenceException-Fehler erzeugt, überprüfen Sie die Teile des Codes, die die Hintergrundverarbeitung starten oder die Verarbeitung fortsetzen, nachdem eine Anforderung erfüllt wurde. Suchen Sie nach Fehlern, wie das Definieren einer Controllermethode als async void.

So werden Hintergrundaufgaben mit HttpContext-Daten sicher ausgeführt

• Kopieren Sie die benötigten Daten während der Verarbeitung der Anforderung.
• Übergeben Sie die kopierten Daten an eine Hintergrundaufgabe.
• Verweisen Sie in parallelen Aufgaben nicht auf HttpContext-Daten. Extrahieren Sie die erforderlichen Daten aus dem Kontext, bevor Sie die parallelen Aufgaben starten.

Um unsicheren Code zu vermeiden, übergeben Sie HttpContext niemals an eine Methode, die im Hintergrund arbeitet. Übergeben Sie stattdessen die erforderlichen Daten. Im folgenden Beispiel wird SendEmail von SendEmailCoreAsync aufgerufen, um mit dem Senden einer E-Mail zu beginnen. Der Wert des Headers X-Correlation-Id wird an SendEmailCoreAsync statt HttpContext übergeben. Die Codeausführung wartet nicht auf den Abschluss von SendEmailCoreAsync:

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 Komponenten (Blazor)

Weitere Informationen finden Sie unter IHttpContextAccessor/HttpContext in ASP.NET Core Blazor Apps.