Skip to content

6. Gültigkeitsbereiche von Daten

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer sendet zahlreiche Anfragen. Daten können daher auf drei Ebenen geteilt werden, die als Scope (Gültigkeitsbereich) bezeichnet werden:

  • Anwendungs-Scope: Die Daten werden von allen Benutzern während der gesamten Lebensdauer des Servers geteilt (zum Beispiel die Liste der Ärzte);
  • Anfrage-Scope: Die Daten existieren nur für die Dauer einer Anfrage (das Modell einer View);
  • Client-Scope: Die Daten sind benutzerspezifisch und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, der angemeldete Benutzer).

Der ursprüngliche Kurs ([ASP.NET MVC], 2013) verwendete für diesen letzten Scope eine Sitzung: einen vom Server verwalteten Speicherbereich, der jedem Browser zugeordnet ist. [ASP.NET Core] verwendet diesen Ansatz weiterhin ([AddSession]), aber dieses Dokument verzichtet, ebenso wie die Fallstudie, darauf: Daten mit Client-Scope werden vom Browser in Cookies gespeichert. Der Server behält zwischen den Anfragen desselben Benutzers keinerlei Daten: Man sagt, er sei zustandslos ([stateless]). Dadurch ist es zum Beispiel möglich, mehrere identische Server hinter einem Load Balancer zu betreiben. Der Preis dafür: Ein Cookie steht unter der Kontrolle des Benutzers, der es lesen und ändern kann. Deshalb werden dort nur unkritische Daten gespeichert – oder Daten, die vom Server signiert oder verschlüsselt werden, sodass dieser jede Änderung erkennen kann: Das ist beim [TempData]-Cookie (Beispiel 20) und beim Authentifizierungs-Token (Kapitel 8) der Fall.

Auf der Serverseite entsprechen der Anwendungs- und der Anfrage-Scope den Lebensdauern der Services der Dependency Injection (siehe Beispiel 06). [ASP.NET Core] kennt drei davon:

Registrierung
Lebensdauer
Eine Instanz ...
AddSingleton
Anwendung
für die gesamte Lebensdauer der Anwendung, von allen Anfragen gemeinsam genutzt
AddScoped
Anfrage
pro HTTP-Anfrage, von allen gemeinsam genutzt, die sie während dieser Anfrage anfordern
AddTransient
keine
Bei jeder Injection: zwei Anfragen, zwei Instanzen

6.1. Beispiel 23: drei Scopes

Die Datei [Services/CounterService.cs]:

namespace Example23.Services;

// Geltungsbereich ANWENDUNG (AddSingleton): eine einzige Instanz, von
// ALLEN Anfragen ALLER Benutzer gemeinsam genutzt
public class CounterService
{
    private int total;

    // mehrere Anfragen können GLEICHZEITIG laufen: Interlocked
    // garantiert, dass zwei gleichzeitige Inkremente nicht verloren gehen
    public int Increment() => Interlocked.Increment(ref total);
}
  • Zeile 7: Der Service wird ein Singleton sein (siehe [Program.cs]): Sein Feld [total] hat daher Anwendungs-Scope;
  • Zeile 11: Ein Webserver verarbeitet mehrere Anfragen gleichzeitig auf mehreren Threads ([threads]). Führen zwei Anfragen gleichzeitig [total++] aus, können beide denselben Wert lesen, und eine Erhöhung geht verloren. [Interlocked.Increment] führt Lesen, Addieren und Schreiben in einer einzigen, unteilbaren Operation aus. Ein Singleton-Service muss sich stets vor solchen gleichzeitigen Zugriffen in Acht nehmen.

Die Datei [Services/RequestService.cs]:

namespace Example23.Services;

// Geltungsbereich ANFRAGE (AddScoped): eine NEUE Instanz für jede HTTP-Anfrage,
// gemeinsam genutzt von allen, die sie WÄHREND dieser Anfrage anfordern
public class RequestService
{
    private static int createdInstances; // static: ein Zähler, der von allen Instanzen gemeinsam genutzt wird

    public int Number { get; } = Interlocked.Increment(ref createdInstances);
}
  • Zeile 7: Ein Feld mit dem Modifizierer [static] gehört zur Klasse und nicht zu einer Instanz; es wird von allen Instanzen gemeinsam genutzt. Es zählt die Anzahl der erzeugten Instanzen;
  • Zeile 9: Jeder Instanz wird bei ihrer Erzeugung eine Nummer zugewiesen. Der Service hat Anfrage-Scope: Die Nummer ändert sich mit jeder Anfrage.

Die Datei [Services/ToolService.cs]:

namespace Example23.Services;

// Geltungsbereich TRANSIENT (AddTransient): eine NEUE Instanz bei JEDER Injektion,
// auch innerhalb einer einzigen Anfrage
public class ToolService
{
    private static int createdInstances;

    public int Number { get; } = Interlocked.Increment(ref createdInstances);
}

Derselbe Instanzenzähler für einen [transient]-Service.

Die Datei [Program.cs]:

using System.Text.Encodings.Web;
using System.Text.Unicode;
using Example23.Services;
using Microsoft.Extensions.FileProviders;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
builder.Services.AddSingleton(HtmlEncoder.Create(UnicodeRanges.All));
// die drei Lebensdauern eines Services
builder.Services.AddSingleton<CounterService>(); // eine Instanz für die gesamte Anwendung
builder.Services.AddScoped<RequestService>();    // eine Instanz pro Anfrage
builder.Services.AddTransient<ToolService>();    // eine Instanz pro Injektion

var app = builder.Build();

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "common", "bootstrap"))),
    RequestPath = "/bootstrap",
});

// Geltungsbereich ANFRAGE: HttpContext.Items entsteht und endet mit der Anfrage
app.Use(async (context, next) =>
{
    context.Items["start"] = DateTime.Now.ToString("HH:mm:ss.fff");
    await next(context);
});

app.MapControllers();
app.Run();
  • Zeilen 10–12: die drei Lebensdauern;
  • Zeilen 23–26: Eine Middleware speichert den Empfangszeitpunkt der Anfrage in ***[HttpContext.Items], einem Dictionary, das zusammen mit der Anfrage erzeugt und zerstört wird. Alles, was die Anfrage verarbeitet (Filter, Controller, View), kann darin lesen und schreiben. Das entspricht [res.locals]* in [Express].

Die Datei [Controllers/ScopesController.cs]:

using Example23.Services;
using Microsoft.AspNetCore.Mvc;

namespace Example23.Controllers;

public record ScopesModel(int Total, int Instance, int Tool, int MyVisits);

public class ScopesController(CounterService counter, RequestService request, ToolService tool) : Controller
{
    [HttpGet("/")]
    public IActionResult Scopes()
    {
        // Geltungsbereich CLIENT: ein vom BROWSER aufbewahrtes Datum (Cookie),
        // das bei jeder Anfrage an den Server zurückgesendet wird
        int.TryParse(Request.Cookies["myVisits"], out var myVisits);
        myVisits++;
        Response.Cookies.Append("myVisits", myVisits.ToString(),
            new CookieOptions { HttpOnly = true, SameSite = SameSiteMode.Lax });
        return View(new ScopesModel(counter.Increment(), request.Number, tool.Number, myVisits));
    }
}
  • Zeile 8: Die drei Services werden injiziert;
  • Zeilen 15–18: der Client-Scope: ein in einem Cookie gespeicherter Zähler. [Request.Cookies["myVisits"]] liest das vom Browser gesendete Cookie ([null] beim ersten Besuch). [int.TryParse] wandelt es in eine Ganzzahl um; schlägt die Umwandlung fehl, wird [myVisits] auf 0 gesetzt. Die Action erhöht den Wert und setzt das Cookie neu;
  • Zeile 19: Die Werte werden an die View übergeben.

Die Datei [Views/Scopes/Scopes.cshtml]:

@model ScopesModel
@* @inject: die View fordert die Services ebenfalls an, während DERSELBEN Anfrage *@
@inject RequestService RequestOfTheView
@inject ToolService ToolOfTheView
<h1 class="h3">The scopes of data</h1>
<ul>
  <li>application: @Model.Total visit(s) to the site, all browsers combined</li>
  <li>request: instance no. @Model.Instance of RequestService (no. @RequestOfTheView.Number in the view),
    request received at @Context.Items["start"]</li>
  <li>transient: instance no. @Model.Tool of ToolService (no. @ToolOfTheView.Number in the view)</li>
  <li>client: @Model.MyVisits visit(s) from this browser</li>
</ul>
  • Zeilen 3–4: Die Direktive [@inject Type Name] fordert einen Service vom Dependency-Injection-Container an und speichert ihn in einer Eigenschaft der View. Die View wird während derselben Anfrage wie die Action ausgeführt: Wir können die vom Controller und von der View erhaltenen Instanzen vergleichen;
  • Zeile 9: der Wert mit Anfrage-Scope, von der Middleware gesetzt.

Eine Seite unter der URL http://localhost:5000/:

Image

Simulieren wir zwei Browser mit [curl] und zwei Cookie-Dateien, [a.txt] und [b.txt]. Browser A sendet zwei Anfragen, dann Browser B eine, und schließlich A noch eine:

1
2
3
4
curl -c a.txt -b a.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
curl -c b.txt -b b.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
browser A:
application: 1 visit(s) to the site, all browsers combined
request: instance no. 1 of RequestService (no. 1 in the view), request received at 12:19:46.574
transient: instance no. 1 of ToolService (no. 2 in the view)
client: 1 visit(s) from this browser

browser A:
application: 2 visit(s) to the site, all browsers combined
request: instance no. 2 of RequestService (no. 2 in the view), request received at 12:19:46.671
transient: instance no. 3 of ToolService (no. 4 in the view)
client: 2 visit(s) from this browser

browser B:
application: 3 visit(s) to the site, all browsers combined
request: instance no. 3 of RequestService (no. 3 in the view), request received at 12:19:46.687
transient: instance no. 5 of ToolService (no. 6 in the view)
client: 1 visit(s) from this browser

browser A:
application: 4 visit(s) to the site, all browsers combined
request: instance no. 4 of RequestService (no. 4 in the view), request received at 12:19:46.696
transient: instance no. 7 of ToolService (no. 8 in the view)
client: 3 visit(s) from this browser

(nur die Listenelemente sind dargestellt). Wir stellen fest:

  • Der Anwendungszähler zählt alle Besuche: 1, 2, 3, 4;
  • Jede Anfrage hat ihre eigene Instanz von [RequestService]: 1, 2, 3, 4. Während einer Anfrage erhalten der Controller und die View dieselbe Instanz;
  • Jede Injection von [ToolService] erzeugt eine Instanz: Der Controller und die View erhalten zwei verschiedene, und jede Anfrage erzeugt zwei neue;
  • Der Client-Zähler ist für jeden Browser spezifisch: A hat 3 Besuche, B hat 1.

Das Cookie wird vom Client kontrolliert, der jeden beliebigen Wert senden kann:

curl -i -b "myVisits=41" http://localhost:5000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Set-Cookie: myVisits=42; path=/; samesite=lax; httponly

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
<ul>
  <li>application: 6 visit(s) to the site, all browsers combined</li>
  <li>request: instance no. 6 of RequestService (no. 6 in the view),
    request received at 12:19:47.374</li>
  <li>transient: instance no. 11 of ToolService (no. 12 in the view)</li>
  <li>client: 42 visit(s) from this browser</li>
</ul>

  </div>
</body>
</html>

Für einen Besuchszähler ist das belanglos. Bei sensiblen Daten (die Identität des Benutzers, seine Rolle) muss der Server Manipulationen erkennen können: Kapitel 8 zeigt, wie.

Aus diesen Lebensdauern folgt eine Regel: Ein Service darf nicht von einem Service mit kürzerer Lebensdauer abhängen. Ein Singleton, das einen Service wie [Scoped] erhielte, würde ihn unbegrenzt behalten, weit über die Anfrage hinaus, für die er erzeugt wurde. [ASP.NET Core] prüft die Einhaltung dieser Regel beim Start im Entwicklungsmodus und verweigert den Start, wenn die Regel verletzt wird. In der Fallstudie:

Scope
Daten
Wo?
Anwendung
Listen der Ärzte und Kunden, Wörterbücher, ausstehende CAPTCHAs, Versuchszähler
Singleton-Services ([ListCache], [Translator], [CaptchaService]...)
Anfrage
Datenbankzugriff ([DbContext]), Repositories, Geschäftsschicht, gemeinsames View-Modell; angemeldeter Benutzer
[Scoped]-Services ([RdvMedecinsDbContext], [BusinessService], [ApplicationModel]...) ; [HttpContext.User], [HttpContext.Items]
Client
Authentifizierungs-Token, Sprache, Flash-Meldung
Cookies