Richtlinien basierte Autorisierung in ASP.net CorePolicy-based authorization in ASP.NET Core

Im Hintergrund werden bei der rollenbasierten Autorisierung und der Anspruchs basierten Autorisierung eine Anforderung, ein Anforderungs Handler und eine vorkonfigurierte Richtlinie verwendet.Underneath the covers, role-based authorization and claims-based authorization use a requirement, a requirement handler, and a pre-configured policy. Diese Bausteine unterstützen den Ausdruck der Autorisierungs Auswertungen im Code.These building blocks support the expression of authorization evaluations in code. Das Ergebnis ist eine umfangreichere, wiederverwendbare, testbare Autorisierungs Struktur.The result is a richer, reusable, testable authorization structure.

Eine Autorisierungs Richtlinie besteht aus einer oder mehreren Anforderungen.An authorization policy consists of one or more requirements. Sie wird als Teil der Autorisierungs Dienst Konfiguration in der Startup.ConfigureServices -Methode registriert:It's registered as part of the authorization service configuration, in the Startup.ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();
    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });
}

Im vorherigen Beispiel wird eine Richtlinie "AtLeast21" erstellt.In the preceding example, an "AtLeast21" policy is created. Sie verfügt über eine einzige—Anforderung, die ein minimal Alter ist, das als Parameter für die Anforderung angegeben wird.It has a single requirement—that of a minimum age, which is supplied as a parameter to the requirement.

IAuthorizationServiceIAuthorizationService

Der primäre Dienst, der bestimmt, ob die Autorisierung erfolgreich war, ist IAuthorizationService:The primary service that determines if authorization is successful is IAuthorizationService:

/// <summary>
/// Checks policy based permissions for a user
/// </summary>
public interface IAuthorizationService
{
    /// <summary>
    /// Checks if a user meets a specific set of requirements for the specified resource
    /// </summary>
    /// <param name="user">The user to evaluate the requirements against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="requirements">The requirements to evaluate.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// This value is <value>true</value> when the user fulfills the policy; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check 
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, 
                                     IEnumerable<IAuthorizationRequirement> requirements);

    /// <summary>
    /// Checks if a user meets a specific authorization policy
    /// </summary>
    /// <param name="user">The user to check the policy against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="policyName">The name of the policy to check against a specific 
    /// context.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// Returns a flag indicating whether the user, and optional resource has fulfilled 
    /// the policy.    
    /// <value>true</value> when the policy has been fulfilled; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(
                                ClaimsPrincipal user, object resource, string policyName);
}

Im vorangehenden Code werden die beiden Methoden des IAuthorizationServicehervorgehoben.The preceding code highlights the two methods of the IAuthorizationService.

IAuthorizationRequirementist ein markerdienst ohne Methoden und der Mechanismus für die Überwachung, ob die Autorisierung erfolgreich war.IAuthorizationRequirement is a marker service with no methods, and the mechanism for tracking whether authorization is successful.

Jeder IAuthorizationHandler ist für die Überprüfung zuständig, ob die Anforderungen erfüllt sind:Each IAuthorizationHandler is responsible for checking if requirements are met:

/// <summary>
/// Classes implementing this interface are able to make a decision if authorization
/// is allowed.
/// </summary>
public interface IAuthorizationHandler
{
    /// <summary>
    /// Makes a decision if authorization is allowed.
    /// </summary>
    /// <param name="context">The authorization information.</param>
    Task HandleAsync(AuthorizationHandlerContext context);
}

Mit AuthorizationHandlerContext der-Klasse wird der Handler verwendet, um zu kennzeichnen, ob Anforderungen erfüllt sind:The AuthorizationHandlerContext class is what the handler uses to mark whether requirements have been met:

 context.Succeed(requirement)

Der folgende Code zeigt die vereinfachte (und mit Kommentaren versehene) Standard Implementierung des Autorisierungs Dienstanbieter:The following code shows the simplified (and annotated with comments) default implementation of the authorization service:

public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, 
             object resource, IEnumerable<IAuthorizationRequirement> requirements)
{
    // Create a tracking context from the authorization inputs.
    var authContext = _contextFactory.CreateContext(requirements, user, resource);

    // By default this returns an IEnumerable<IAuthorizationHandlers> from DI.
    var handlers = await _handlers.GetHandlersAsync(authContext);

    // Invoke all handlers.
    foreach (var handler in handlers)
    {
        await handler.HandleAsync(authContext);
    }

    // Check the context, by default success is when all requirements have been met.
    return _evaluator.Evaluate(authContext);
}

Der folgende Code zeigt ein typisches ConfigureServices:The following code shows a typical ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    // Add all of your handlers to DI.
    services.AddSingleton<IAuthorizationHandler, MyHandler1>();
    // MyHandler2, ...

    services.AddSingleton<IAuthorizationHandler, MyHandlerN>();

    // Configure your policies
    services.AddAuthorization(options =>
          options.AddPolicy("Something",
          policy => policy.RequireClaim("Permission", "CanViewPage", "CanViewAnything")));


    services.AddControllersWithViews();
    services.AddRazorPages();
}

Verwenden IAuthorizationService Sie [Authorize(Policy = "Something")] oder für die Autorisierung.Use IAuthorizationService or [Authorize(Policy = "Something")] for authorization.

Anwenden von Richtlinien auf MVC-ControllerApplying policies to MVC controllers

Wenn Sie Seiten verwenden Razor , finden Sie weitere Informationen unter Anwenden von Richtlinien Razor auf Seiten in diesem Dokument.If you're using Razor Pages, see Applying policies to Razor Pages in this document.

Richtlinien werden mithilfe des [Authorize] -Attributs mit dem Richtlinien Namen auf Controller angewendet.Policies are applied to controllers by using the [Authorize] attribute with the policy name. Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseController : Controller
{
    public IActionResult Index() => View();
}

Anwenden von Richt Razor Linien auf SeitenApplying policies to Razor Pages

Richtlinien werden mithilfe Razor des [Authorize] -Attributs mit dem Richtlinien Namen auf Seiten angewendet.Policies are applied to Razor Pages by using the [Authorize] attribute with the policy name. Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseModel : PageModel
{
}

Richtlinien können auch mithilfe einer Razor Autorisierungs Konventionauf Seiten angewendet werden.Policies can also be applied to Razor Pages by using an authorization convention.

AnforderungenRequirements

Eine Autorisierungs Anforderung ist eine Auflistung von Daten Parametern, die eine Richtlinie verwenden kann, um den aktuellen Benutzer Prinzipal auszuwerten.An authorization requirement is a collection of data parameters that a policy can use to evaluate the current user principal. In unserer Richtlinie "AtLeast21" ist die Anforderung ein einzelner Parameter—das minimale Alter.In our "AtLeast21" policy, the requirement is a single parameter—the minimum age. Eine Anforderung implementiert iauthorizationrequirements, bei dem es sich um eine leere markerschnittstelle handelt.A requirement implements IAuthorizationRequirement, which is an empty marker interface. Eine parametrisierte minimale Alters Anforderung kann wie folgt implementiert werden:A parameterized minimum age requirement could be implemented as follows:

using Microsoft.AspNetCore.Authorization;

public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }

    public MinimumAgeRequirement(int minimumAge)
    {
        MinimumAge = minimumAge;
    }
}

Wenn eine Autorisierungs Richtlinie mehrere Autorisierungs Anforderungen enthält, müssen alle Anforderungen bestanden werden, damit die Richtlinien Auswertung erfolgreich ist.If an authorization policy contains multiple authorization requirements, all requirements must pass in order for the policy evaluation to succeed. Anders ausgedrückt: mehrere Autorisierungs Anforderungen, die einer einzelnen Autorisierungs Richtlinie hinzugefügt werden, werden auf der Grundlage von und behandelt.In other words, multiple authorization requirements added to a single authorization policy are treated on an AND basis.

Hinweis

Eine Anforderung muss keine Daten oder Eigenschaften haben.A requirement doesn't need to have data or properties.

Autorisierungs HandlerAuthorization handlers

Ein Autorisierungs Handler ist dafür verantwortlich, die Eigenschaften einer Anforderung zu evaluieren.An authorization handler is responsible for the evaluation of a requirement's properties. Der Autorisierungs Handler wertet die Anforderungen anhand eines angegebenen authorizationhandlercontext aus, um zu bestimmen, ob der Zugriff zulässig ist.The authorization handler evaluates the requirements against a provided AuthorizationHandlerContext to determine if access is allowed.

Eine Anforderung kann mehrere Handleraufweisen.A requirement can have multiple handlers. Ein Handler kann die authorizationhandler<-trequirement ->TRequirement erben, wobei die zu behandelnde Anforderung ist.A handler may inherit AuthorizationHandler<TRequirement>, where TRequirement is the requirement to be handled. Alternativ kann ein Handler iauthorizationhandler implementieren, um mehr als eine Art von Anforderung zu verarbeiten.Alternatively, a handler may implement IAuthorizationHandler to handle more than one type of requirement.

Verwenden eines Handlers für eine AnforderungUse a handler for one requirement

Im folgenden finden Sie ein Beispiel für eine 1:1-Beziehung, bei der ein minimaler Alters Handler eine einzige Anforderung verwendet:The following is an example of a one-to-one relationship in which a minimum age handler utilizes a single requirement:

using System;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   MinimumAgeRequirement requirement)
    {
        if (!context.User.HasClaim(c => c.Type == ClaimTypes.DateOfBirth &&
                                        c.Issuer == "http://contoso.com"))
        {
            //TODO: Use the following if targeting a version of
            //.NET Framework older than 4.6:
            //      return Task.FromResult(0);
            return Task.CompletedTask;
        }

        var dateOfBirth = Convert.ToDateTime(
            context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth && 
                                        c.Issuer == "http://contoso.com").Value);

        int calculatedAge = DateTime.Today.Year - dateOfBirth.Year;
        if (dateOfBirth > DateTime.Today.AddYears(-calculatedAge))
        {
            calculatedAge--;
        }

        if (calculatedAge >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Der vorangehende Code bestimmt, ob der aktuelle Benutzer Prinzipal über ein Geburtsdatum des Geburts Anspruchs verfügt, das von einem bekannten und vertrauenswürdigen Aussteller ausgestellt wurde.The preceding code determines if the current user principal has a date of birth claim which has been issued by a known and trusted Issuer. Die Autorisierung kann nicht ausgeführt werden, wenn der Anspruch fehlt. in diesem Fall wird eine abgeschlossene Aufgabe zurückgegeben.Authorization can't occur when the claim is missing, in which case a completed task is returned. Wenn ein Anspruch vorhanden ist, wird das Alter des Benutzers berechnet.When a claim is present, the user's age is calculated. Wenn der Benutzer das durch die Anforderung definierte mindestage erfüllt, wird die Autorisierung als erfolgreich eingestuft.If the user meets the minimum age defined by the requirement, authorization is deemed successful. Wenn die Autorisierung erfolgreich context.Succeed ist, wird mit der Erfüllung der Anforderungen als einziger Parameter aufgerufen.When authorization is successful, context.Succeed is invoked with the satisfied requirement as its sole parameter.

Verwenden eines Handlers für mehrere AnforderungenUse a handler for multiple requirements

Im folgenden finden Sie ein Beispiel für eine 1: n-Beziehung, in der ein Berechtigungs Handler drei verschiedene Arten von Anforderungen verarbeiten kann:The following is an example of a one-to-many relationship in which a permission handler can handle three different types of requirements:

using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class PermissionHandler : IAuthorizationHandler
{
    public Task HandleAsync(AuthorizationHandlerContext context)
    {
        var pendingRequirements = context.PendingRequirements.ToList();

        foreach (var requirement in pendingRequirements)
        {
            if (requirement is ReadPermission)
            {
                if (IsOwner(context.User, context.Resource) ||
                    IsSponsor(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
            else if (requirement is EditPermission ||
                     requirement is DeletePermission)
            {
                if (IsOwner(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }

    private bool IsOwner(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }

    private bool IsSponsor(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }
}

Der vorangehende Code durchsucht die " pdingrequirequirements—"-Eigenschaft mit den Anforderungen, die nicht als erfolgreich gekennzeichnet sind.The preceding code traverses PendingRequirements—a property containing requirements not marked as successful. Für eine ReadPermission Anforderung muss der Benutzer entweder ein Besitzer oder ein Sponsor sein, um auf die angeforderte Ressource zuzugreifen.For a ReadPermission requirement, the user must be either an owner or a sponsor to access the requested resource. Bei einer EditPermission -oder DeletePermission -Anforderung muss er ein Besitzer sein, um auf die angeforderte Ressource zugreifen zu können.In the case of an EditPermission or DeletePermission requirement, he or she must be an owner to access the requested resource.

HandlerregistrierungHandler registration

Handler werden während der Konfiguration in der Dienste-Sammlung registriert.Handlers are registered in the services collection during configuration. Beispiel:For example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();
    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });

    services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();
}

Der vorangehende Code MinimumAgeHandler wird als Singleton registriert, services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();indem aufgerufen wird.The preceding code registers MinimumAgeHandler as a singleton by invoking services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();. Handler können mithilfe einer beliebigen integrierten Dienst Lebensdauerregistriert werden.Handlers can be registered using any of the built-in service lifetimes.

Was sollte ein Handler zurückgeben?What should a handler return?

Beachten Sie, Handle dass die-Methode im handlerbeispiel keinen Wert zurückgibt.Note that the Handle method in the handler example returns no value. Wie wird der Status "erfolgreich" oder "Fehler" angegeben?How is a status of either success or failure indicated?

  • Ein Handler gibt den Erfolg durch context.Succeed(IAuthorizationRequirement requirement)Aufrufen von an und übergibt die Anforderung, die erfolgreich überprüft wurde.A handler indicates success by calling context.Succeed(IAuthorizationRequirement requirement), passing the requirement that has been successfully validated.

  • Ein Handler muss im Allgemeinen keine Fehler behandeln, da andere Handler für dieselbe Anforderung erfolgreich ausgeführt werden können.A handler doesn't need to handle failures generally, as other handlers for the same requirement may succeed.

  • Um einen Fehler zu gewährleisten, müssen Sie, auch wenn andere context.FailAnforderungs Handler erfolgreich sind, den BefehlTo guarantee failure, even if other requirement handlers succeed, call context.Fail.

Wenn ein Handler oder context.Succeed context.Failaufruft, werden alle anderen Handler immer noch aufgerufen.If a handler calls context.Succeed or context.Fail, all other handlers are still called. Dies ermöglicht die Generierung von Nebeneffekten, wie z. b. die Protokollierung, die auch dann stattfindet, wenn ein anderer Handler eine Anforderung erfolgreich überprüft oder nicht erfüllt hat.This allows requirements to produce side effects, such as logging, which takes place even if another handler has successfully validated or failed a requirement. Wenn diese Eigenschaft falseauf festgelegt ist, wird die Ausführung von Handlern durch die invokehandlersafterfailure -Eigenschaft (verfügbar in ASP.net Core 1,1 context.Fail und höher) kurz beendet, wenn aufgerufen wird.When set to false, the InvokeHandlersAfterFailure property (available in ASP.NET Core 1.1 and later) short-circuits the execution of handlers when context.Fail is called. InvokeHandlersAfterFailureder Standard trueWert ist. in diesem Fall werden alle Handler aufgerufen.InvokeHandlersAfterFailure defaults to true, in which case all handlers are called.

Hinweis

Autorisierungs Handler werden auch dann aufgerufen, wenn die Authentifizierung fehlschlägt.Authorization handlers are called even if authentication fails.

Warum sollte ich mehrere Handler für eine Anforderung wünschen?Why would I want multiple handlers for a requirement?

Wenn Sie evaluieren möchten, können Sie mehrere Handler für eine einzelne Anforderung implementieren.In cases where you want evaluation to be on an OR basis, implement multiple handlers for a single requirement. Beispielsweise verfügt Microsoft über Türen, die nur mit Schlüsselkarten geöffnet werden.For example, Microsoft has doors which only open with key cards. Wenn Sie Ihre Schlüsselkarte zuhause lassen, druckt die Rezeption einen temporären Aufkleber und öffnet die Tür für Sie.If you leave your key card at home, the receptionist prints a temporary sticker and opens the door for you. In diesem Szenario verfügen Sie über eine einzige Anforderung, buildingentry, aber mehrere Handler, die jeweils eine einzelne Anforderung untersuchen.In this scenario, you'd have a single requirement, BuildingEntry, but multiple handlers, each one examining a single requirement.

BuildingEntryRequirement.csBuildingEntryRequirement.cs

using Microsoft.AspNetCore.Authorization;

public class BuildingEntryRequirement : IAuthorizationRequirement
{
}

BadgeEntryHandler.csBadgeEntryHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class BadgeEntryHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "BadgeId" &&
                                       c.Issuer == "http://microsoftsecurity"))
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

TemporaryStickerHandler.csTemporaryStickerHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class TemporaryStickerHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, 
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "TemporaryBadgeId" &&
                                       c.Issuer == "https://microsoftsecurity"))
        {
            // We'd also check the expiration date on the sticker.
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Stellen Sie sicher, dass beide Handler registriertsind.Ensure that both handlers are registered. Wenn einer der beiden Handler erfolgreich ist, wenn BuildingEntryRequirementeine Richtlinie den auswertet, ist die Richtlinien Auswertung erfolgreich.If either handler succeeds when a policy evaluates the BuildingEntryRequirement, the policy evaluation succeeds.

Verwenden eines Func zum erfüllen einer RichtlinieUsing a func to fulfill a policy

Es kann Situationen geben, in denen das erfüllen einer Richtlinie einfach im Code ausgedrückt werden kann.There may be situations in which fulfilling a policy is simple to express in code. Beim Konfigurieren Ihrer Richtlinie mit Func<AuthorizationHandlerContext, bool> dem RequireAssertion Richtlinien Generator ist es möglich, eine bereitzustellen.It's possible to supply a Func<AuthorizationHandlerContext, bool> when configuring your policy with the RequireAssertion policy builder.

Die vorherige BadgeEntryHandler könnte z. b. wie folgt umgeschrieben werden:For example, the previous BadgeEntryHandler could be rewritten as follows:

services.AddAuthorization(options =>
{
     options.AddPolicy("BadgeEntry", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(c =>
                (c.Type == "BadgeId" ||
                 c.Type == "TemporaryBadgeId") &&
                 c.Issuer == "https://microsoftsecurity")));
});

Zugreifen auf den MVC-Anforderungs Kontext in HandlernAccessing MVC request context in handlers

Die HandleRequirementAsync Methode, die Sie in einem Autorisierungs Handler implementieren, verfügt AuthorizationHandlerContext über zwei TRequirement Parameter: einen und den, den Sie behandeln.The HandleRequirementAsync method you implement in an authorization handler has two parameters: an AuthorizationHandlerContext and the TRequirement you are handling. Frameworks wie z. b. MVC oder jabbr können ein beliebiges Resource Objekt zur- AuthorizationHandlerContext Eigenschaft hinzufügen, um zusätzliche Informationen zu übergeben.Frameworks such as MVC or Jabbr are free to add any object to the Resource property on the AuthorizationHandlerContext to pass extra information.

MVC übergibt z. b. eine Instanz von authorizationfiltercontext in Resource der-Eigenschaft.For example, MVC passes an instance of AuthorizationFilterContext in the Resource property. Diese Eigenschaft ermöglicht den Zugriff HttpContextauf RouteData, und alles andere, was von MVC Razor und Seiten bereitgestellt wird.This property provides access to HttpContext, RouteData, and everything else provided by MVC and Razor Pages.

Die Verwendung der- Resource Eigenschaft ist Framework-spezifisch.The use of the Resource property is framework specific. Die Verwendung von Informationen Resource in der-Eigenschaft schränkt Ihre Autorisierungs Richtlinien auf bestimmte Frameworks ein.Using information in the Resource property limits your authorization policies to particular frameworks. Sie sollten die Resource -Eigenschaft mit dem is -Schlüsselwort umwandeln und dann bestätigen, dass die Umwandlung erfolgreich war, um sicherzustellen InvalidCastException , dass der Code nicht mit einem stürztYou should cast the Resource property using the is keyword, and then confirm the cast has succeeded to ensure your code doesn't crash with an InvalidCastException when run on other frameworks:

// Requires the following import:
//     using Microsoft.AspNetCore.Mvc.Filters;
if (context.Resource is AuthorizationFilterContext mvcContext)
{
    // Examine MVC-specific things like routing data.
}

Im Hintergrund werden bei der rollenbasierten Autorisierung und der Anspruchs basierten Autorisierung eine Anforderung, ein Anforderungs Handler und eine vorkonfigurierte Richtlinie verwendet.Underneath the covers, role-based authorization and claims-based authorization use a requirement, a requirement handler, and a pre-configured policy. Diese Bausteine unterstützen den Ausdruck der Autorisierungs Auswertungen im Code.These building blocks support the expression of authorization evaluations in code. Das Ergebnis ist eine umfangreichere, wiederverwendbare, testbare Autorisierungs Struktur.The result is a richer, reusable, testable authorization structure.

Eine Autorisierungs Richtlinie besteht aus einer oder mehreren Anforderungen.An authorization policy consists of one or more requirements. Sie wird als Teil der Autorisierungs Dienst Konfiguration in der Startup.ConfigureServices -Methode registriert:It's registered as part of the authorization service configuration, in the Startup.ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });
}

Im vorherigen Beispiel wird eine Richtlinie "AtLeast21" erstellt.In the preceding example, an "AtLeast21" policy is created. Sie verfügt über eine einzige—Anforderung, die ein minimal Alter ist, das als Parameter für die Anforderung angegeben wird.It has a single requirement—that of a minimum age, which is supplied as a parameter to the requirement.

IAuthorizationServiceIAuthorizationService

Der primäre Dienst, der bestimmt, ob die Autorisierung erfolgreich war, ist IAuthorizationService:The primary service that determines if authorization is successful is IAuthorizationService:

/// <summary>
/// Checks policy based permissions for a user
/// </summary>
public interface IAuthorizationService
{
    /// <summary>
    /// Checks if a user meets a specific set of requirements for the specified resource
    /// </summary>
    /// <param name="user">The user to evaluate the requirements against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="requirements">The requirements to evaluate.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// This value is <value>true</value> when the user fulfills the policy; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check 
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, object resource, 
                                     IEnumerable<IAuthorizationRequirement> requirements);

    /// <summary>
    /// Checks if a user meets a specific authorization policy
    /// </summary>
    /// <param name="user">The user to check the policy against.</param>
    /// <param name="resource">
    /// An optional resource the policy should be checked with.
    /// If a resource is not required for policy evaluation you may pass null as the value
    /// </param>
    /// <param name="policyName">The name of the policy to check against a specific 
    /// context.</param>
    /// <returns>
    /// A flag indicating whether authorization has succeeded.
    /// Returns a flag indicating whether the user, and optional resource has fulfilled 
    /// the policy.    
    /// <value>true</value> when the policy has been fulfilled; 
    /// otherwise <value>false</value>.
    /// </returns>
    /// <remarks>
    /// Resource is an optional parameter and may be null. Please ensure that you check
    /// it is not null before acting upon it.
    /// </remarks>
    Task<AuthorizationResult> AuthorizeAsync(
                                ClaimsPrincipal user, object resource, string policyName);
}

Im vorangehenden Code werden die beiden Methoden des IAuthorizationServicehervorgehoben.The preceding code highlights the two methods of the IAuthorizationService.

IAuthorizationRequirementist ein markerdienst ohne Methoden und der Mechanismus für die Überwachung, ob die Autorisierung erfolgreich war.IAuthorizationRequirement is a marker service with no methods, and the mechanism for tracking whether authorization is successful.

Jeder IAuthorizationHandler ist für die Überprüfung zuständig, ob die Anforderungen erfüllt sind:Each IAuthorizationHandler is responsible for checking if requirements are met:

/// <summary>
/// Classes implementing this interface are able to make a decision if authorization
/// is allowed.
/// </summary>
public interface IAuthorizationHandler
{
    /// <summary>
    /// Makes a decision if authorization is allowed.
    /// </summary>
    /// <param name="context">The authorization information.</param>
    Task HandleAsync(AuthorizationHandlerContext context);
}

Mit AuthorizationHandlerContext der-Klasse wird der Handler verwendet, um zu kennzeichnen, ob Anforderungen erfüllt sind:The AuthorizationHandlerContext class is what the handler uses to mark whether requirements have been met:

 context.Succeed(requirement)

Der folgende Code zeigt die vereinfachte (und mit Kommentaren versehene) Standard Implementierung des Autorisierungs Dienstanbieter:The following code shows the simplified (and annotated with comments) default implementation of the authorization service:

public async Task<AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, 
             object resource, IEnumerable<IAuthorizationRequirement> requirements)
{
    // Create a tracking context from the authorization inputs.
    var authContext = _contextFactory.CreateContext(requirements, user, resource);

    // By default this returns an IEnumerable<IAuthorizationHandlers> from DI.
    var handlers = await _handlers.GetHandlersAsync(authContext);

    // Invoke all handlers.
    foreach (var handler in handlers)
    {
        await handler.HandleAsync(authContext);
    }

    // Check the context, by default success is when all requirements have been met.
    return _evaluator.Evaluate(authContext);
}

Der folgende Code zeigt ein typisches ConfigureServices:The following code shows a typical ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    // Add all of your handlers to DI.
    services.AddSingleton<IAuthorizationHandler, MyHandler1>();
    // MyHandler2, ...

    services.AddSingleton<IAuthorizationHandler, MyHandlerN>();

    // Configure your policies
    services.AddAuthorization(options =>
          options.AddPolicy("Something",
          policy => policy.RequireClaim("Permission", "CanViewPage", "CanViewAnything")));


    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Verwenden IAuthorizationService Sie [Authorize(Policy = "Something")] oder für die Autorisierung.Use IAuthorizationService or [Authorize(Policy = "Something")] for authorization.

Anwenden von Richtlinien auf MVC-ControllerApplying policies to MVC controllers

Wenn Sie Seiten verwenden Razor , finden Sie weitere Informationen unter Anwenden von Richtlinien Razor auf Seiten in diesem Dokument.If you're using Razor Pages, see Applying policies to Razor Pages in this document.

Richtlinien werden mithilfe des [Authorize] -Attributs mit dem Richtlinien Namen auf Controller angewendet.Policies are applied to controllers by using the [Authorize] attribute with the policy name. Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseController : Controller
{
    public IActionResult Index() => View();
}

Anwenden von Richt Razor Linien auf SeitenApplying policies to Razor Pages

Richtlinien werden mithilfe Razor des [Authorize] -Attributs mit dem Richtlinien Namen auf Seiten angewendet.Policies are applied to Razor Pages by using the [Authorize] attribute with the policy name. Beispiel:For example:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

[Authorize(Policy = "AtLeast21")]
public class AlcoholPurchaseModel : PageModel
{
}

Richtlinien können auch mithilfe einer Razor Autorisierungs Konventionauf Seiten angewendet werden.Policies can also be applied to Razor Pages by using an authorization convention.

AnforderungenRequirements

Eine Autorisierungs Anforderung ist eine Auflistung von Daten Parametern, die eine Richtlinie verwenden kann, um den aktuellen Benutzer Prinzipal auszuwerten.An authorization requirement is a collection of data parameters that a policy can use to evaluate the current user principal. In unserer Richtlinie "AtLeast21" ist die Anforderung ein einzelner Parameter—das minimale Alter.In our "AtLeast21" policy, the requirement is a single parameter—the minimum age. Eine Anforderung implementiert iauthorizationrequirements, bei dem es sich um eine leere markerschnittstelle handelt.A requirement implements IAuthorizationRequirement, which is an empty marker interface. Eine parametrisierte minimale Alters Anforderung kann wie folgt implementiert werden:A parameterized minimum age requirement could be implemented as follows:

using Microsoft.AspNetCore.Authorization;

public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }

    public MinimumAgeRequirement(int minimumAge)
    {
        MinimumAge = minimumAge;
    }
}

Wenn eine Autorisierungs Richtlinie mehrere Autorisierungs Anforderungen enthält, müssen alle Anforderungen bestanden werden, damit die Richtlinien Auswertung erfolgreich ist.If an authorization policy contains multiple authorization requirements, all requirements must pass in order for the policy evaluation to succeed. Anders ausgedrückt: mehrere Autorisierungs Anforderungen, die einer einzelnen Autorisierungs Richtlinie hinzugefügt werden, werden auf der Grundlage von und behandelt.In other words, multiple authorization requirements added to a single authorization policy are treated on an AND basis.

Hinweis

Eine Anforderung muss keine Daten oder Eigenschaften haben.A requirement doesn't need to have data or properties.

Autorisierungs HandlerAuthorization handlers

Ein Autorisierungs Handler ist dafür verantwortlich, die Eigenschaften einer Anforderung zu evaluieren.An authorization handler is responsible for the evaluation of a requirement's properties. Der Autorisierungs Handler wertet die Anforderungen anhand eines angegebenen authorizationhandlercontext aus, um zu bestimmen, ob der Zugriff zulässig ist.The authorization handler evaluates the requirements against a provided AuthorizationHandlerContext to determine if access is allowed.

Eine Anforderung kann mehrere Handleraufweisen.A requirement can have multiple handlers. Ein Handler kann die authorizationhandler<-trequirement ->TRequirement erben, wobei die zu behandelnde Anforderung ist.A handler may inherit AuthorizationHandler<TRequirement>, where TRequirement is the requirement to be handled. Alternativ kann ein Handler iauthorizationhandler implementieren, um mehr als eine Art von Anforderung zu verarbeiten.Alternatively, a handler may implement IAuthorizationHandler to handle more than one type of requirement.

Verwenden eines Handlers für eine AnforderungUse a handler for one requirement

Im folgenden finden Sie ein Beispiel für eine 1:1-Beziehung, bei der ein minimaler Alters Handler eine einzige Anforderung verwendet:The following is an example of a one-to-one relationship in which a minimum age handler utilizes a single requirement:

using System;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   MinimumAgeRequirement requirement)
    {
        if (!context.User.HasClaim(c => c.Type == ClaimTypes.DateOfBirth &&
                                        c.Issuer == "http://contoso.com"))
        {
            //TODO: Use the following if targeting a version of
            //.NET Framework older than 4.6:
            //      return Task.FromResult(0);
            return Task.CompletedTask;
        }

        var dateOfBirth = Convert.ToDateTime(
            context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth && 
                                        c.Issuer == "http://contoso.com").Value);

        int calculatedAge = DateTime.Today.Year - dateOfBirth.Year;
        if (dateOfBirth > DateTime.Today.AddYears(-calculatedAge))
        {
            calculatedAge--;
        }

        if (calculatedAge >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Der vorangehende Code bestimmt, ob der aktuelle Benutzer Prinzipal über ein Geburtsdatum des Geburts Anspruchs verfügt, das von einem bekannten und vertrauenswürdigen Aussteller ausgestellt wurde.The preceding code determines if the current user principal has a date of birth claim which has been issued by a known and trusted Issuer. Die Autorisierung kann nicht ausgeführt werden, wenn der Anspruch fehlt. in diesem Fall wird eine abgeschlossene Aufgabe zurückgegeben.Authorization can't occur when the claim is missing, in which case a completed task is returned. Wenn ein Anspruch vorhanden ist, wird das Alter des Benutzers berechnet.When a claim is present, the user's age is calculated. Wenn der Benutzer das durch die Anforderung definierte mindestage erfüllt, wird die Autorisierung als erfolgreich eingestuft.If the user meets the minimum age defined by the requirement, authorization is deemed successful. Wenn die Autorisierung erfolgreich context.Succeed ist, wird mit der Erfüllung der Anforderungen als einziger Parameter aufgerufen.When authorization is successful, context.Succeed is invoked with the satisfied requirement as its sole parameter.

Verwenden eines Handlers für mehrere AnforderungenUse a handler for multiple requirements

Im folgenden finden Sie ein Beispiel für eine 1: n-Beziehung, in der ein Berechtigungs Handler drei verschiedene Arten von Anforderungen verarbeiten kann:The following is an example of a one-to-many relationship in which a permission handler can handle three different types of requirements:

using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class PermissionHandler : IAuthorizationHandler
{
    public Task HandleAsync(AuthorizationHandlerContext context)
    {
        var pendingRequirements = context.PendingRequirements.ToList();

        foreach (var requirement in pendingRequirements)
        {
            if (requirement is ReadPermission)
            {
                if (IsOwner(context.User, context.Resource) ||
                    IsSponsor(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
            else if (requirement is EditPermission ||
                     requirement is DeletePermission)
            {
                if (IsOwner(context.User, context.Resource))
                {
                    context.Succeed(requirement);
                }
            }
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }

    private bool IsOwner(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }

    private bool IsSponsor(ClaimsPrincipal user, object resource)
    {
        // Code omitted for brevity

        return true;
    }
}

Der vorangehende Code durchsucht die " pdingrequirequirements—"-Eigenschaft mit den Anforderungen, die nicht als erfolgreich gekennzeichnet sind.The preceding code traverses PendingRequirements—a property containing requirements not marked as successful. Für eine ReadPermission Anforderung muss der Benutzer entweder ein Besitzer oder ein Sponsor sein, um auf die angeforderte Ressource zuzugreifen.For a ReadPermission requirement, the user must be either an owner or a sponsor to access the requested resource. Bei einer EditPermission -oder DeletePermission -Anforderung muss er ein Besitzer sein, um auf die angeforderte Ressource zugreifen zu können.In the case of an EditPermission or DeletePermission requirement, he or she must be an owner to access the requested resource.

HandlerregistrierungHandler registration

Handler werden während der Konfiguration in der Dienste-Sammlung registriert.Handlers are registered in the services collection during configuration. Beispiel:For example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.AddAuthorization(options =>
    {
        options.AddPolicy("AtLeast21", policy =>
            policy.Requirements.Add(new MinimumAgeRequirement(21)));
    });

    services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();
}

Der vorangehende Code MinimumAgeHandler wird als Singleton registriert, services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();indem aufgerufen wird.The preceding code registers MinimumAgeHandler as a singleton by invoking services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();. Handler können mithilfe einer beliebigen integrierten Dienst Lebensdauerregistriert werden.Handlers can be registered using any of the built-in service lifetimes.

Was sollte ein Handler zurückgeben?What should a handler return?

Beachten Sie, Handle dass die-Methode im handlerbeispiel keinen Wert zurückgibt.Note that the Handle method in the handler example returns no value. Wie wird der Status "erfolgreich" oder "Fehler" angegeben?How is a status of either success or failure indicated?

  • Ein Handler gibt den Erfolg durch context.Succeed(IAuthorizationRequirement requirement)Aufrufen von an und übergibt die Anforderung, die erfolgreich überprüft wurde.A handler indicates success by calling context.Succeed(IAuthorizationRequirement requirement), passing the requirement that has been successfully validated.

  • Ein Handler muss im Allgemeinen keine Fehler behandeln, da andere Handler für dieselbe Anforderung erfolgreich ausgeführt werden können.A handler doesn't need to handle failures generally, as other handlers for the same requirement may succeed.

  • Um einen Fehler zu gewährleisten, müssen Sie, auch wenn andere context.FailAnforderungs Handler erfolgreich sind, den BefehlTo guarantee failure, even if other requirement handlers succeed, call context.Fail.

Wenn ein Handler oder context.Succeed context.Failaufruft, werden alle anderen Handler immer noch aufgerufen.If a handler calls context.Succeed or context.Fail, all other handlers are still called. Dies ermöglicht die Generierung von Nebeneffekten, wie z. b. die Protokollierung, die auch dann stattfindet, wenn ein anderer Handler eine Anforderung erfolgreich überprüft oder nicht erfüllt hat.This allows requirements to produce side effects, such as logging, which takes place even if another handler has successfully validated or failed a requirement. Wenn diese Eigenschaft falseauf festgelegt ist, wird die Ausführung von Handlern durch die invokehandlersafterfailure -Eigenschaft (verfügbar in ASP.net Core 1,1 context.Fail und höher) kurz beendet, wenn aufgerufen wird.When set to false, the InvokeHandlersAfterFailure property (available in ASP.NET Core 1.1 and later) short-circuits the execution of handlers when context.Fail is called. InvokeHandlersAfterFailureder Standard trueWert ist. in diesem Fall werden alle Handler aufgerufen.InvokeHandlersAfterFailure defaults to true, in which case all handlers are called.

Hinweis

Autorisierungs Handler werden auch dann aufgerufen, wenn die Authentifizierung fehlschlägt.Authorization handlers are called even if authentication fails.

Warum sollte ich mehrere Handler für eine Anforderung wünschen?Why would I want multiple handlers for a requirement?

Wenn Sie evaluieren möchten, können Sie mehrere Handler für eine einzelne Anforderung implementieren.In cases where you want evaluation to be on an OR basis, implement multiple handlers for a single requirement. Beispielsweise verfügt Microsoft über Türen, die nur mit Schlüsselkarten geöffnet werden.For example, Microsoft has doors which only open with key cards. Wenn Sie Ihre Schlüsselkarte zuhause lassen, druckt die Rezeption einen temporären Aufkleber und öffnet die Tür für Sie.If you leave your key card at home, the receptionist prints a temporary sticker and opens the door for you. In diesem Szenario verfügen Sie über eine einzige Anforderung, buildingentry, aber mehrere Handler, die jeweils eine einzelne Anforderung untersuchen.In this scenario, you'd have a single requirement, BuildingEntry, but multiple handlers, each one examining a single requirement.

BuildingEntryRequirement.csBuildingEntryRequirement.cs

using Microsoft.AspNetCore.Authorization;

public class BuildingEntryRequirement : IAuthorizationRequirement
{
}

BadgeEntryHandler.csBadgeEntryHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class BadgeEntryHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "BadgeId" &&
                                       c.Issuer == "http://microsoftsecurity"))
        {
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

TemporaryStickerHandler.csTemporaryStickerHandler.cs

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using PoliciesAuthApp1.Services.Requirements;

public class TemporaryStickerHandler : AuthorizationHandler<BuildingEntryRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, 
                                                   BuildingEntryRequirement requirement)
    {
        if (context.User.HasClaim(c => c.Type == "TemporaryBadgeId" &&
                                       c.Issuer == "https://microsoftsecurity"))
        {
            // We'd also check the expiration date on the sticker.
            context.Succeed(requirement);
        }

        //TODO: Use the following if targeting a version of
        //.NET Framework older than 4.6:
        //      return Task.FromResult(0);
        return Task.CompletedTask;
    }
}

Stellen Sie sicher, dass beide Handler registriertsind.Ensure that both handlers are registered. Wenn einer der beiden Handler erfolgreich ist, wenn BuildingEntryRequirementeine Richtlinie den auswertet, ist die Richtlinien Auswertung erfolgreich.If either handler succeeds when a policy evaluates the BuildingEntryRequirement, the policy evaluation succeeds.

Verwenden eines Func zum erfüllen einer RichtlinieUsing a func to fulfill a policy

Es kann Situationen geben, in denen das erfüllen einer Richtlinie einfach im Code ausgedrückt werden kann.There may be situations in which fulfilling a policy is simple to express in code. Beim Konfigurieren Ihrer Richtlinie mit Func<AuthorizationHandlerContext, bool> dem RequireAssertion Richtlinien Generator ist es möglich, eine bereitzustellen.It's possible to supply a Func<AuthorizationHandlerContext, bool> when configuring your policy with the RequireAssertion policy builder.

Die vorherige BadgeEntryHandler könnte z. b. wie folgt umgeschrieben werden:For example, the previous BadgeEntryHandler could be rewritten as follows:

services.AddAuthorization(options =>
{
     options.AddPolicy("BadgeEntry", policy =>
        policy.RequireAssertion(context =>
            context.User.HasClaim(c =>
                (c.Type == "BadgeId" ||
                 c.Type == "TemporaryBadgeId") &&
                 c.Issuer == "https://microsoftsecurity")));
});

Zugreifen auf den MVC-Anforderungs Kontext in HandlernAccessing MVC request context in handlers

Die HandleRequirementAsync Methode, die Sie in einem Autorisierungs Handler implementieren, verfügt AuthorizationHandlerContext über zwei TRequirement Parameter: einen und den, den Sie behandeln.The HandleRequirementAsync method you implement in an authorization handler has two parameters: an AuthorizationHandlerContext and the TRequirement you are handling. Frameworks wie MVC oder SignalR können jedes beliebige Objekt der Resource -Eigenschaft im hinzufügen AuthorizationHandlerContext , um zusätzliche Informationen zu übergeben.Frameworks such as MVC or SignalR are free to add any object to the Resource property on the AuthorizationHandlerContext to pass extra information.

Wenn Sie das Endpunkt Routing verwenden, wird die Autorisierung in der Regel von der Autorisierungs Middleware verarbeitet.When using endpoint routing, authorization is typically handled by the Authorization Middleware. In diesem Fall ist die Resource Eigenschaft eine Instanz von Endpoint.In this case, the Resource property is an instance of Endpoint. Der Endpunkt kann verwendet werden, um die zugrunde liegende Ressource, an die Sie weiterleiten, zu überprüfen.The endpoint can be used to probe the underlying the resource to which you're routing. Beispiel:For example:

if (context.Resource is Endpoint endpoint)
{
   var actionDescriptor = endpoint.Metadata.GetMetadata<ControllerActionDescriptor>();
   ...
}

Mit herkömmlichem Routing oder wenn die Autorisierung im Rahmen des Autorisierungs Filters von MVC erfolgt, Resource ist der AuthorizationFilterContext Wert von eine Instanz von.With traditional routing, or when authorization happens as part of MVC's authorization filter, the value of Resource is an AuthorizationFilterContext instance. Diese Eigenschaft ermöglicht den Zugriff HttpContextauf RouteData, und alles andere, was von MVC Razor und Seiten bereitgestellt wird.This property provides access to HttpContext, RouteData, and everything else provided by MVC and Razor Pages.

Die Verwendung der- Resource Eigenschaft ist Framework-spezifisch.The use of the Resource property is framework specific. Die Verwendung von Informationen Resource in der-Eigenschaft schränkt Ihre Autorisierungs Richtlinien auf bestimmte Frameworks ein.Using information in the Resource property limits your authorization policies to particular frameworks. Sie sollten die Resource -Eigenschaft mit dem is -Schlüsselwort umwandeln und dann bestätigen, dass die Umwandlung erfolgreich war, um sicherzustellen InvalidCastException , dass der Code nicht mit einem stürztYou should cast the Resource property using the is keyword, and then confirm the cast has succeeded to ensure your code doesn't crash with an InvalidCastException when run on other frameworks:

// Requires the following import:
//     using Microsoft.AspNetCore.Mvc.Filters;
if (context.Resource is AuthorizationFilterContext mvcContext)
{
    // Examine MVC-specific things like routing data.
}