C# Academy · Leçon

Exigences d’autorisation personnalisées

Créez des exigences et des gestionnaires personnalisés.

Leçon 4 sur 413 étapes

Exigences d’autorisation personnalisées est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Quand les mécanismes intégrés ne suffisent pas

Certaines règles ne peuvent pas être exprimées avec RequireRole ou RequireClaim ; par exemple, « avoir au moins 18 ans » ou « être propriétaire de cette ressource ».

Pour cela, vous écrivez une exigence ainsi qu’un gestionnaire personnalisés.

// Rule: user must be older than a configurable minimum age

IAuthorizationRequirement

Une exigence est un marqueur qui contient les données de la règle. Elle implémente l’interface vide IAuthorizationRequirement.

public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }
    public MinimumAgeRequirement(int minimumAge) =>
        MinimumAge = minimumAge;
}

AuthorizationHandler

Un gestionnaire contient la logique. Dérivez de AuthorizationHandler<TRequirement> et redéfinissez HandleRequirementAsync.

public class MinimumAgeHandler
    : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        MinimumAgeRequirement requirement)
    {
        // logic goes here
        return Task.CompletedTask;
    }
}

Valider l’exigence

Dans le gestionnaire, examinez les claims de l’utilisateur. Si la règle est satisfaite, appelez context.Succeed(requirement). Dans le cas contraire, retournez simplement la main sans l’appeler.

var dobClaim = context.User.FindFirst("birthdate");
if (dobClaim is null) return Task.CompletedTask;

var dob = DateTime.Parse(dobClaim.Value);
int age = DateTime.UtcNow.Year - dob.Year;
if (dob > DateTime.UtcNow.AddYears(-age)) age--;

if (age >= requirement.MinimumAge)
    context.Succeed(requirement);

return Task.CompletedTask;

Valider, sans échouer

Préférez appeler Succeed lorsque l’exigence est satisfaite et ne rien faire dans le cas contraire. N’appelez context.Fail() que si vous voulez garantir l’échec, quels que soient les autres gestionnaires de la même exigence.

// Soft: let other handlers also try
if (ok) context.Succeed(requirement);

// Hard: force failure no matter what
if (blocked) context.Fail();

Enregistrer le gestionnaire

Enregistrez les gestionnaires dans DI en tant que IAuthorizationHandler. Il s’agit généralement d’instances uniques, sauf s’ils dépendent de services associés à une portée.

builder.Services.AddSingleton<
    IAuthorizationHandler, MinimumAgeHandler>();

Associer une exigence à une politique

Ajoutez l’exigence à une politique nommée avec AddRequirements (ou Requirements.Add). Le gestionnaire est automatiquement associé selon son type.

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AtLeast18", policy =>
        policy.AddRequirements(new MinimumAgeRequirement(18)));
});

Utiliser la politique

Appliquez-la comme n’importe quelle autre politique nommée.

[Authorize(Policy = "AtLeast18")]
[HttpGet("age-restricted")]
public IActionResult Restricted() => Ok();

Autorisation fondée sur une ressource

Pour autoriser l’accès à une instance précise (par exemple, « seul le propriétaire du document peut le modifier »), utilisez la surcharge qui accepte une ressource. La ressource est transmise au contexte du gestionnaire.

public class OwnerHandler
    : AuthorizationHandler<OwnerRequirement, Document>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        OwnerRequirement requirement,
        Document resource)
    {
        var userId = context.User.FindFirstValue(
            ClaimTypes.NameIdentifier);
        if (resource.OwnerId.ToString() == userId)
            context.Succeed(requirement);
        return Task.CompletedTask;
    }
}

Appeler IAuthorizationService

Les vérifications fondées sur une ressource s’exécutent explicitement dans une action via le IAuthorizationService injecté.

public async Task<IActionResult> Edit(int id)
{
    var doc = await _db.Documents.FindAsync(id);
    var result = await _authz.AuthorizeAsync(
        User, doc, "DocumentOwner");
    if (!result.Succeeded) return Forbid();
    return Ok(doc);
}

Plusieurs gestionnaires pour une exigence

Une exigence peut disposer de plusieurs gestionnaires ; si l’un quelconque d’entre eux réussit, l’exigence est satisfaite. Cela modélise proprement les conditions OR (sauf si un gestionnaire appelle Fail).

// e.g. allow if owner OR if admin role
services.AddSingleton<IAuthorizationHandler, OwnerHandler>();
services.AddSingleton<IAuthorizationHandler, AdminOverrideHandler>();

Vérification rapide

Testez votre compréhension des gestionnaires.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez créé une autorisation personnalisée :

Un IAuthorizationRequirement contient les données de la règle.
Un AuthorizationHandler<T> contient la logique et appelle Succeed.
Enregistrez le gestionnaire en tant que IAuthorizationHandler et associez l’exigence à une politique.
Les gestionnaires fondés sur une ressource et IAuthorizationService autorisent l’accès à des instances précises.

Le cours d’autorisation est maintenant terminé.

Gratuit pour commencer

Apprends C# avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 93
Leçons: 346

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Exigences d’autorisation personnalisées » est-elle gratuite ?

Oui — le texte complet de « Exigences d’autorisation personnalisées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Exigences d’autorisation personnalisées » ?

Créez des exigences et des gestionnaires personnalisés. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Exigences d’autorisation personnalisées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Autorisation fondée sur les rôles
Autorisation fondée sur les revendications
Autorisation fondée sur des politiques
Exigences d’autorisation personnalisées

← Retour à C# Academy