Comparer les droits requis et accordés lors d'une mise à jour
Quand une nouvelle version exige des droits que la licence du client n'a jamais accordés, un simple « fonction verrouillée » est une impasse. Voici comment comparer requis et accordés pour dire exactement quoi acheter.
Un client de votre ligne 3.x passe à la 4.0. La nouvelle version ajoute le SSO, un exportateur de journal d”audit et un plafond de projets plus élevé : trois choses que sa licence actuelle, émise contre le modèle de niveau 3.x, n”a jamais été conçue pour couvrir. Il démarre, clique sur Exporter le journal d”audit et obtient une sèche FeatureLockedException. Il clique sur Paramètres SSO et en obtient une autre. Chaque clic raté est un ticket de support distinct, et aucun ne répond à la seule question que le client se pose vraiment : que dois-je acheter pour que cette version soit complète ?
Le problème n”est pas la barrière. Conditionner chaque fonction en mode « fermé par défaut » est correct et vous devez le garder. Le problème est que les contrôles IsEnabled par fonction répondent à une question de la mauvaise taille. Ils vous disent, au moment de l”usage, si une capacité est activée. Ils ne vous disent jamais, à l”avance, la forme de l”écart entre ce dont cette version de l”application a besoin et ce que cette licence accorde. Cette forme est une différence d”ensembles, et la calculer une fois au démarrage transforme un filet de verrouillages mystérieux en une phrase honnête.
Un droit est une capacité nommée ; une version exige un ensemble de droits
Si vous avez lu droits et feature flags, vous savez qu”un droit Keyright est une capacité nommée gravée dans la licence signée : un booléen comme audit-export, ou une limite numérique comme max-projects: 50. La licence porte l”ensemble que le client a reçu. Ce qu”elle ne porte pas, et ne doit pas porter, c”est l”ensemble que votre build actuel exige, car cet ensemble change à chaque livraison.
Déclarez-le donc dans l”application. Un manifeste de capacités est une petite description statique de chaque droit dont dépend une version donnée, versionnée aux côtés du code qui en dépend. Il voyage dans l”assembly ; ce n”est ni un secret ni un artefact de licence.
public sealed record Requirement(string Key, RequirementKind Kind, long Min = 0);
public enum RequirementKind { Flag, Limit }
public static class AppManifest
{
// Everything THIS build needs the license to grant. Grows as the product grows.
public static readonly IReadOnlyList<Requirement> Required = new[]
{
new Requirement("audit-export", RequirementKind.Flag),
new Requirement("sso", RequirementKind.Flag),
new Requirement("max-projects", RequirementKind.Limit, Min: 25),
};
}
Quand vous ajoutez en 4.0 une fonction qui s”appuie sur sso, vous ajoutez une ligne ici dans le même commit. Le manifeste est le seul endroit qui sait « cette version a besoin de ces capacités », et il vit à côté du code : il ne peut donc jamais se désynchroniser d”une version comme le ferait une configuration externe.
L”ensemble accordé vient de la licence validée
L”autre moitié de la comparaison est ce que la licence accorde réellement, et c”est du calcul purement local. Le SDK a validé la licence signée hors ligne contre votre clé publique embarquée au démarrage ; lire ses droits ne fait qu”inspecter le résultat.
var client = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = AcmeKeys.LicensePublicKey, // public key only; safe to ship
ServiceUrl = "https://licensing.acme.example",
});
LicenseInfo info = client.Validate(); // never throws; fails closed to Free on any problem
Validate() n”atteint jamais le réseau sur le chemin critique, ne lève jamais d”exception, et en cas d”échec renvoie un LicenseInfo en édition Free dont l”ensemble de droits est vide. Cette dernière propriété compte pour la comparaison : une licence invalide ou absente ne casse pas la comparaison, elle n”accorde simplement rien, de sorte que toutes les exigences apparaissent comme manquantes — ce qui est exactement le rapport souhaité dans ce cas.
La comparaison est de l”arithmétique d”ensembles
Parcourez maintenant l”ensemble requis face à la licence accordée et collectez ce qui n”est pas satisfait. Un booléen est satisfait quand la licence l”active ; une limite est satisfaite quand le plafond de la licence atteint ou dépasse le minimum dont cette version a besoin.
public sealed record Gap(Requirement Need, long? Granted);
public static IReadOnlyList<Gap> Diff(LicenseInfo info, IEnumerable<Requirement> required)
{
var gaps = new List<Gap>();
foreach (var r in required)
{
switch (r.Kind)
{
case RequirementKind.Flag:
if (!info.Entitlements.IsEnabled(r.Key))
gaps.Add(new Gap(r, Granted: null));
break;
case RequirementKind.Limit:
long granted = info.Entitlements.GetLimit(r.Key); // 0 when absent
if (granted < r.Min)
gaps.Add(new Gap(r, Granted: granted));
break;
}
}
return gaps;
}
Comme IsEnabled et GetLimit échouent en mode fermé — un booléen inconnu se lit comme désactivé, une limite absente se lit comme 0 — la comparaison est correcte même face à une licence Free ou malformée, sans le moindre cas particulier. La liste des manques est la réponse : vide signifie que cette version est entièrement couverte ; non vide est une liste de courses précise et achetable.
Signalez-le une fois, au démarrage
Exécutez la comparaison au démarrage de l”application et exposez tout l”écart en un seul endroit — une bannière, une boîte de dialogue bloquante, une ligne de log pour un hôte sans interface — au lieu de laisser l”utilisateur buter sur chaque verrou l”un après l”autre. Le message nomme ce qui manque et pointe vers la mise à niveau, l”action qui résout tout d”un coup.
var gaps = EntitlementDiff.Diff(info, AppManifest.Required);
if (gaps.Count > 0)
{
var lines = gaps.Select(g => g.Granted is null
? $" • {g.Need.Key} (not included in your license)"
: $" • {g.Need.Key}: need {g.Need.Min}, your license allows {g.Granted}");
_log.LogWarning(
"This version of acme-suite needs entitlements your current license ({Tier}) does " +
"not cover:\n{Gaps}\nUpgrade your license to enable them: {Url}",
info.Tier, string.Join('\n', lines), "https://acme.example/account/license");
_startup.ShowUpgradeNotice(gaps); // one notice, the full shopping list, a real next step
}
Notez ce que cela ne fait pas : cela ne désactive pas l”application. Un manque signifie que certaines fonctions de la 4.0 sont indisponibles, non que le produit soit sans licence. Tout ce que la licence accorde vraiment continue de fonctionner ; les barrières par fonction restent exactement là où elles étaient et se ferment toujours au point d”usage. La comparaison est une invitation à la mise à niveau, pas un coupe-circuit : les deux vivent à des couches différentes et ne se substituent jamais.
Faites de la comparaison aussi un contrôle préalable
Le même manifeste rapporte avant qu”un seul octet de la nouvelle version n”atteigne un client. Un partenaire qui déploie sur un parc, ou votre propre CI, peut émettre une licence de test au niveau actuel et affirmer que la comparaison est vide, attrapant « la 4.0 a silencieusement besoin d”un droit que le modèle du niveau Pro n”accorde jamais » au moment de la compilation plutôt que dans une file de support.
[Fact]
public void ProTier_covers_everything_v4_requires()
{
LicenseInfo pro = TestIssuer.Mint(product: "acme-suite", tier: "Pro");
var gaps = EntitlementDiff.Diff(pro, AppManifest.Required);
Assert.True(gaps.Count == 0,
"Pro tier is missing: " + string.Join(", ", gaps.Select(g => g.Need.Key)));
}
Si ce test passe au rouge quand vous ajoutez une fonction, vous avez une décision à prendre avant la publication : élargir le modèle du niveau pour que Pro accorde le nouveau droit, ou accepter que la fonction soit une montée en gamme vers un niveau supérieur. Dans les deux cas vous avez tranché délibérément, l”écart sous les yeux, au lieu de le découvrir par le premier client qui a mis à jour et trouvé un bouton verrouillé.
La forme de lӎcart est le produit de la comparaison
Conditionner par fonction dit à l”utilisateur qu”une porte est verrouillée. Comparer le manifeste à la licence lui dit lesquelles, pourquoi et quel achat unique les ouvre toutes : la différence entre un filet frustrant de verrouillages et une invitation unique, honnête et actionnable. Gardez les barrières fermées par défaut : elles sont votre contrôle. Ajoutez par-dessus la comparaison au démarrage : elle est votre explication. L”une est la façon dont le logiciel protège l”entreprise ; l”autre est la façon dont l”entreprise empêche le client d”abandonner, furieux, une mise à niveau qu”il aurait payée avec plaisir.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.