Skip to content
← Tous les articles
· Delta1 Labs Blazor ServerKeyright

Licencier une app Blazor Server par circuit

Dans Blazor Server, une portée DI vit pendant tout le circuit SignalR, pas par requête — si bien qu'une licence validée à la connexion d'un onglet reste la réponse trois jours plus tard, bien après l'expiration du bail. Voici comment cadrer les entitlements Keyright sur le circuit, les maintenir à jour pendant toute sa durée et basculer l'interface en mode dégradé quand elles changent.

Un onglet Blazor Server peut rester ouvert pendant des jours. Derrière lui, un circuit SignalR maintient une portée d’injection de dépendances active pendant toute la connexion — si bien qu’une licence validée au moment de l’ouverture du circuit reste la réponse que donne l’application au troisième jour, bien après l’expiration du bail et la fin de l’essai. En ASP.NET Core avec portée par requête, ce bug ne peut pas se produire : la portée meurt avec la requête. Dans Blazor Server, c’est le comportement par défaut, et c’est précisément ce que la plupart des équipes ratent en greffant du licenciement sur une application rendue côté serveur.

La vraie question : où vit une licence dans un circuit ?

Le réflexe est d’enregistrer un LicenseService à portée, de le lire dans vos composants et de passer à autre chose. En MVC, c’est correct. Dans Blazor Server, cela casse en silence, parce qu’un service à portée n’est pas cadré sur la requête, mais sur le circuit. Blazor crée exactement une portée quand le navigateur établit son circuit et la conserve jusqu’au démontage du circuit. Naviguer entre les pages ne crée pas de nouvelle portée. Cliquer sur des boutons ne crée pas de nouvelle portée. La portée, c’est la connexion.

Ainsi, une licence lue une seule fois dans le constructeur d’un service à portée reste figée pour toute la session. Un client dont l’évaluation de 30 jours expire à minuit conserve toutes les fonctions payantes jusqu’à ce qu’il ferme l’onglet. Ce n’est pas un cas limite théorique ; les tableaux de bord de longue durée sont justement le point fort de Blazor Server.

La solution a trois pièces mobiles : un contexte à portée qui conserve l’instantané courant des entitlements et annonce les changements, un CircuitHandler qui le remplit à la connexion et le maintient à jour pendant la vie du circuit, et des composants qui réagissent aux changements en basculant en mode dégradé, en lecture seule, au lieu de mentir sur ce qui est licencié.

Ongletcircuit SignalRCircuitLicenseContextun par circuit (scoped)LicenseCircuitHandlerValidate() + boucle 5 minSDK Keyright — Validate() hors-ligne, sans réseauFonction activeEntitlements onMode lecture seuleédition basculéevalideexpiréeChanged → StateHasChanged
Une portée par circuit : le gestionnaire prend l'instantané de la licence à la connexion, revalide via un minuteur, et un événement de changement re-rend les composants en lecture seule — le tout hors-ligne.

Étape 1 : un contexte à portée qui échoue fermé et annonce les changements

Le contexte conserve le dernier LicenseInfo et émet un événement quand il est remplacé. Il démarre dans un état d’échec fermé, de sorte que si quelque chose se passe mal avant l’exécution du gestionnaire — pré-rendu, course, gestionnaire qui lève une exception — l’application se comporte comme non licenciée plutôt que déverrouillée.

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 échoue fermé doublement : une licence invalide court-circuite, et le IsEnabled du SDK Keyright lui-même renvoie false pour toute entitlement absente. Il n’existe aucun chemin où une entitlement absente se lit comme active.

Étape 2 : un CircuitHandler qui garde l’instantané frais

CircuitHandler est le point d’accroche du cycle de vie de Blazor Server. Enregistrez-en un à portée et Blazor l’instancie par circuit, appelant OnCircuitOpenedAsync quand la connexion s’établit et OnCircuitClosedAsync quand elle est démontée. Nous prenons l’instantané de la licence à l’ouverture, puis lançons un PeriodicTimer pour la vie du circuit afin qu’une expiration en cours de session soit détectée au lieu d’être mise en cache pour toujours.

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() est un calcul purement local : il vérifie la signature contre la clé publique embarquée, contrôle l’expiration, le verrouillage de nœud et l’état de l’horloge, et lit l’ensemble d’entitlements du bail que le SDK a déjà mis en cache. Il ne touche jamais au réseau et ne lève jamais d’exception, donc l’exécuter toutes les cinq minutes est bon marché et sûr. Nous n’émettons Changed que lorsque l’édition ou la validité bascule réellement, de sorte qu’un circuit en régime stable ne re-rend rien ; l’événement se déclenche exactement sur la transition qui compte — payant vers Community Edition, valide vers expiré.

Étape 3 : des composants qui se dégradent au lieu de mentir

Un composant s’abonne à Changed dans OnInitialized, ramène le re-rendu sur le contexte de synchronisation du moteur de rendu avec InvokeAsync, et se désabonne à la libération. Quand l’édition bascule, le contrôle protégé est remplacé par un avis en lecture seule au lieu de disparaître en silence.

@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;
}

L’événement Changed est émis depuis le thread du pool du minuteur ; InvokeAsync(StateHasChanged) ressaute sur le répartiteur du circuit afin que le re-rendu soit sûr entre threads. L’utilisateur voit le bouton Export se transformer en invite de renouvellement à l’instant où la licence expire, dans un onglet qu’il n’a pas touché — sans rechargement, sans verrouillage brutal, sans plantage.

Le câblage

Trois enregistrements. Le client est singleton (il charge la clé publique une fois et est immuable) ; le contexte et le gestionnaire sont à portée pour qu’il y en ait un de chaque par circuit.

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

Enregistrer CircuitHandler comme type de service (et non la classe concrète) est délibéré : Blazor découvre chaque enregistrement de CircuitHandler et les pilote tous, donc cela se compose avec tout autre point d’accroche de circuit que vous avez déjà.

Mises en garde : là où ça fait mal

Le pré-rendu n’a pas de circuit. Pendant le pré-rendu initial côté serveur, il n’y a pas de connexion SignalR, donc OnCircuitOpenedAsync n’a pas encore tourné et le contexte est encore à LicenseInfo.None. C’est pourquoi il échoue fermé : le premier rendu côté serveur affiche l’interface non licenciée, puis le circuit se connecte et, si licence il y a, les fonctions s’allument. Si ce clignotement est inacceptable, désactivez le pré-rendu pour la page protégée ou lisez la licence de façon synchrone pendant le pré-rendu depuis le client singleton.

Chaque onglet est un circuit. Deux onglets signifient deux portées, deux contextes, deux boucles de revalidation — et, si vous réclamez un siège flottant par circuit, deux sièges. Quand les sièges sont rares, basez la réclamation sur l’utilisateur authentifié, tenez un compteur de références de ses circuits ouverts entre OnCircuitOpenedAsync/OnCircuitClosedAsync et ne libérez que lorsque le compteur atteint zéro. Voyez sièges concurrents flottants pour le côté comptage de baux.

Cinq minutes est une fenêtre, pas une garantie. Une licence qui expire à 12:00 est appliquée à 12:05 au plus tard, jamais avant. Raccourcissez l’intervalle pour une application plus stricte, mais rappelez-vous que la vraie ligne de défense est côté serveur : une barrière d’interface cadrée sur le circuit est une courtoisie envers les utilisateurs honnêtes, pas un substitut à la vérification de l’entitlement là où le travail privilégié s’exécute réellement. Associez-la à des entitlements comme politiques d’autorisation sur votre surface d’API.

À retenir

Le modèle de Blazor Server où la portée est le circuit est le seul fait qui transforme un motif de licenciement ASP.NET Core correct en bug silencieux. Conservez l’instantané des entitlements dans un contexte à portée, rafraîchissez-le depuis le minuteur d’un CircuitHandler tant que le circuit vit, et laissez les composants s’abonner et se dégrader avec élégance — et un onglet laissé ouvert une semaine applique sa licence aussi fidèlement qu’un onglet tout juste ouvert. Le Validate() hors-ligne et sans exception de Keyright est ce qui rend la boucle de revalidation assez bon marché pour tourner indéfiniment.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.