Skip to content
← Alle Beiträge
· Delta1 Labs Blazor ServerKeyright

Eine Blazor-Server-App pro Circuit lizenzieren

In Blazor Server lebt ein DI-Scope für den gesamten SignalR-Circuit, nicht pro Request — eine Lizenz, die beim Verbinden eines Tabs validiert wurde, ist deshalb drei Tage später noch immer die Antwort, lange nach Ablauf des Lease. So begrenzen Sie Keyright-Entitlements auf den Circuit, halten sie über dessen gesamte Lebensdauer frisch und schalten die Oberfläche bei Änderung in einen degradierten Modus.

Ein Blazor-Server-Tab kann tagelang offen bleiben. Dahinter hält ein SignalR-Circuit während der gesamten Verbindung einen Dependency-Injection-Scope am Leben — eine Lizenz, die im Moment des Circuit-Aufbaus validiert wurde, ist deshalb am dritten Tag noch immer die Antwort, die die App gibt, lange nach Ablauf des Lease und der Testphase. In ASP.NET Core mit Scope pro Request kann dieser Fehler nicht auftreten: Der Scope stirbt mit dem Request. In Blazor Server ist er das Standardverhalten — und genau das, was die meisten Teams falsch machen, wenn sie Lizenzierung an eine serverseitig gerenderte App schrauben.

Die eigentliche Frage: Wo lebt eine Lizenz in einem Circuit?

Der Reflex ist, einen scoped LicenseService zu registrieren, ihn in den Komponenten zu lesen und weiterzumachen. In MVC ist das korrekt. In Blazor Server bricht es still, denn ein scoped Service ist nicht an den Request gebunden, sondern an den Circuit. Blazor erzeugt genau einen Scope, wenn der Browser seinen Circuit aufbaut, und behält ihn bis zum Abbau des Circuits. Navigation zwischen Seiten erzeugt keinen neuen Scope. Klicks auf Buttons erzeugen keinen neuen Scope. Der Scope ist die Verbindung.

Eine im Konstruktor eines scoped Service nur einmal gelesene Lizenz bleibt also die ganze Sitzung über eingefroren. Ein Kunde, dessen 30-Tage-Evaluierung um Mitternacht abläuft, behält jede kostenpflichtige Funktion, bis er den Tab schließt. Das ist kein theoretischer Grenzfall; langlebige Dashboards sind genau die Stärke von Blazor Server.

Die Lösung hat drei bewegliche Teile: einen scoped Kontext, der den aktuellen Entitlement-Snapshot hält und Änderungen bekannt gibt, einen CircuitHandler, der ihn beim Verbinden füllt und über die Lebensdauer des Circuits frisch hält, und Komponenten, die auf Änderungen reagieren, indem sie in einen degradierten, schreibgeschützten Modus wechseln, statt über das Lizenzierte zu lügen.

Browser-TabSignalR-CircuitCircuitLicenseContexteiner pro Circuit (scoped)LicenseCircuitHandlerValidate() + 5-Min-SchleifeKeyright-SDK — Validate() offline, ohne NetzFunktion aktivEntitlements onSchreibgeschütztEdition umgesprungengültigabgelaufenChanged → StateHasChanged
Ein Scope pro Circuit: Der Handler nimmt beim Verbinden den Lizenz-Snapshot, revalidiert per Timer, und ein Änderungsereignis rendert die Komponenten schreibgeschützt neu — alles offline.

Schritt 1: ein scoped Kontext, der geschlossen scheitert und Änderungen meldet

Der Kontext hält das letzte LicenseInfo und löst ein Ereignis aus, wenn es ersetzt wird. Er startet in einem geschlossen-scheiternden Zustand, damit die App sich wie unlizenziert statt freigeschaltet verhält, falls vor dem Lauf des Handlers etwas schiefgeht — Pre-Rendering, ein Wettlauf, ein werfender Handler.

using Keyright;

public sealed class CircuitLicenseContext
{
    private LicenseInfo _info = LicenseInfo.None;   // fail closed until the handler fills it

    public LicenseInfo Current => _info;
    public event Action? Changed;

    public bool IsEnabled(string key)
        => _info.IsValid && _info.Entitlements.IsEnabled(key);

    public void Update(LicenseInfo next)
    {
        _info = next;
        Changed?.Invoke();
    }
}

IsEnabled scheitert doppelt geschlossen: Eine ungültige Lizenz schließt kurz, und das IsEnabled des Keyright-SDK selbst liefert false für jedes nicht vorhandene Entitlement. Es gibt keinen Pfad, auf dem ein fehlendes Entitlement als aktiv gelesen wird.

Schritt 2: ein CircuitHandler, der den Snapshot frisch hält

CircuitHandler ist der Lebenszyklus-Haken von Blazor Server. Registrieren Sie einen als scoped, und Blazor instanziiert ihn pro Circuit und ruft OnCircuitOpenedAsync auf, wenn die Verbindung steht, und OnCircuitClosedAsync, wenn sie abgebaut wird. Wir nehmen beim Öffnen den Lizenz-Snapshot und lassen dann einen PeriodicTimer für die Lebensdauer des Circuits laufen, damit ein Ablauf mitten in der Sitzung erkannt wird, statt für immer im Cache zu bleiben.

using Keyright;
using Microsoft.AspNetCore.Components.Server.Circuits;

public sealed class LicenseCircuitHandler : CircuitHandler, IDisposable
{
    private readonly KeyrightClient _client;
    private readonly CircuitLicenseContext _context;
    private readonly CancellationTokenSource _cts = new();

    public LicenseCircuitHandler(KeyrightClient client, CircuitLicenseContext context)
        => (_client, _context) = (client, context);

    public override Task OnCircuitOpenedAsync(Circuit circuit, CancellationToken ct)
    {
        _context.Update(_client.Validate());          // snapshot at connect time
        _ = RevalidateLoop(_cts.Token);               // keep it fresh; don't await
        return Task.CompletedTask;
    }

    private async Task RevalidateLoop(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(5));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
            {
                LicenseInfo next = _client.Validate();   // local, no network round-trip
                LicenseInfo now = _context.Current;
                if (next.Edition != now.Edition || next.IsValid != now.IsValid)
                    _context.Update(next);               // raises Changed → UI refresh
            }
        }
        catch (OperationCanceledException) { /* circuit closed */ }
    }

    public override Task OnCircuitClosedAsync(Circuit circuit, CancellationToken ct)
    {
        _cts.Cancel();
        return Task.CompletedTask;
    }

    public void Dispose() => _cts.Dispose();
}

Validate() ist reine lokale Berechnung: Es prüft die Signatur gegen den eingebetteten öffentlichen Schlüssel, kontrolliert Ablauf, Node-Lock und Uhrzustand und liest die Entitlement-Menge aus dem Lease, das das SDK bereits gecacht hat. Es berührt nie das Netzwerk und wirft nie, also ist der Aufruf alle fünf Minuten günstig und sicher. Wir lösen Changed nur aus, wenn Edition oder Gültigkeit tatsächlich umspringen, sodass ein Circuit im Ruhezustand gar nichts neu rendert; das Ereignis feuert genau bei dem Übergang, der zählt — kostenpflichtig zu Community Edition, gültig zu abgelaufen.

Schritt 3: Komponenten, die degradieren statt zu lügen

Eine Komponente abonniert Changed in OnInitialized, verlagert das Re-Rendering mit InvokeAsync auf den Synchronisationskontext des Renderers und meldet sich bei der Freigabe wieder ab. Springt die Edition um, wird das geschützte Steuerelement durch einen schreibgeschützten Hinweis ersetzt, statt stillschweigend zu verschwinden.

@implements IDisposable
@inject CircuitLicenseContext License

@if (License.IsEnabled("feature.export"))
{
    <button class="btn" @onclick="Export">Export report</button>
}
else
{
    <p class="notice">
        Export is read-only on @License.Current.Edition.
        Your license lapsed — renew to re-enable it without reloading.
    </p>
}

@code {
    protected override void OnInitialized() => License.Changed += OnLicenseChanged;

    private void OnLicenseChanged() => InvokeAsync(StateHasChanged);

    public void Dispose() => License.Changed -= OnLicenseChanged;
}

Das Changed-Ereignis wird vom Thread-Pool-Thread des Timers ausgelöst; InvokeAsync(StateHasChanged) springt zurück auf den Dispatcher des Circuits, damit das Re-Rendering threadsicher ist. Der Nutzer sieht, wie sich der Export-Button in dem Moment, in dem die Lizenz abläuft, in eine Verlängerungsaufforderung verwandelt — in einem Tab, den er nicht angefasst hat: ohne Neuladen, ohne harte Sperre, ohne Absturz.

Die Verdrahtung

Drei Registrierungen. Der Client ist Singleton (er lädt den öffentlichen Schlüssel einmal und ist unveränderlich); Kontext und Handler sind scoped, sodass es je einen pro Circuit gibt.

builder.Services.AddSingleton(new KeyrightClient(o => o.PublicKey = PublicKeys.App));
builder.Services.AddScoped<CircuitLicenseContext>();
builder.Services.AddScoped<CircuitHandler, LicenseCircuitHandler>();

CircuitHandler als Service-Typ zu registrieren (nicht die konkrete Klasse) ist Absicht: Blazor entdeckt jede CircuitHandler-Registrierung und steuert sie alle an, sodass dies mit jedem anderen Circuit-Haken komponiert, den Sie bereits haben.

Vorbehalte: wo es wehtut

Pre-Rendering hat keinen Circuit. Beim anfänglichen serverseitigen Pre-Rendering gibt es keine SignalR-Verbindung, also lief OnCircuitOpenedAsync noch nicht und der Kontext steht noch auf LicenseInfo.None. Darum scheitert er geschlossen: Der erste serverseitig gerenderte Anstrich zeigt die unlizenzierte Oberfläche, dann verbindet sich der Circuit, und bei Lizenz leuchten die Funktionen auf. Ist dieses Flackern inakzeptabel, deaktivieren Sie das Pre-Rendering für die geschützte Seite oder lesen Sie die Lizenz während des Pre-Renderings synchron aus dem Singleton-Client.

Jeder Tab ist ein Circuit. Zwei Tabs bedeuten zwei Scopes, zwei Kontexte, zwei Revalidierungsschleifen — und, wenn Sie pro Circuit einen Floating-Sitz beanspruchen, zwei Sitze. Sind Sitze knapp, knüpfen Sie den Sitzanspruch an den authentifizierten Nutzer, zählen Sie dessen offene Circuits per Referenzzählung über OnCircuitOpenedAsync/OnCircuitClosedAsync und geben Sie erst frei, wenn der Zähler null erreicht. Siehe Floating-Concurrent-Sitze für die Lease-Zählseite.

Fünf Minuten sind ein Fenster, keine Garantie. Eine Lizenz, die um 12:00 abläuft, wird spätestens um 12:05 durchgesetzt, nie früher. Verkürzen Sie das Intervall für strengere Durchsetzung, aber denken Sie daran, dass die eigentliche Verteidigungslinie serverseitig liegt: Ein auf den Circuit begrenztes UI-Gate ist eine Höflichkeit gegenüber ehrlichen Nutzern, kein Ersatz für die Prüfung des Entitlements dort, wo die privilegierte Arbeit tatsächlich ausgeführt wird. Kombinieren Sie es mit Entitlements als Autorisierungsrichtlinien auf Ihrer API-Fläche.

Fazit

Das Modell von Blazor Server, in dem der Scope der Circuit ist, ist die eine Tatsache, die ein korrektes ASP.NET-Core-Lizenzierungsmuster in einen stillen Fehler verwandelt. Halten Sie den Entitlement-Snapshot in einem scoped Kontext, frischen Sie ihn vom Timer eines CircuitHandler auf, solange der Circuit lebt, und lassen Sie Komponenten abonnieren und elegant degradieren — dann setzt ein eine Woche offen gelassener Tab seine Lizenz so treu durch wie ein gerade geöffneter. Keyrights offline laufendes, nie werfendes Validate() ist das, was die Revalidierungsschleife günstig genug macht, um für immer zu laufen.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.