ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Methode

Referenz

Definition

Namespace:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Lädt beim Überschreiben in einer abgeleiteten Klasse die benutzerdefinierte Konfiguration aus XML ab.

public:
 virtual void LoadCustomConfiguration(System::Xml::XmlNodeList ^ nodelist);

public virtual void LoadCustomConfiguration (System.Xml.XmlNodeList nodelist);

abstract member LoadCustomConfiguration : System.Xml.XmlNodeList -> unit
override this.LoadCustomConfiguration : System.Xml.XmlNodeList -> unit

Public Overridable Sub LoadCustomConfiguration (nodelist As XmlNodeList)

Parameter

nodelist: XmlNodeList

Die benutzerdefinierten Konfigurationselemente. Jeder Knoten in der Liste ist vom Typ XmlElement.

Implementiert

LoadCustomConfiguration(XmlNodeList)

Beispiele

Die Codebeispiele, die in den ClaimsAuthorizationManager Themen verwendet werden, stammen aus dem Claims Based Authorization Beispiel. Dieses Beispiel stellt einen benutzerdefinierten Berechtigungsautorisierungs-Manager bereit, der Subjekte basierend auf einer Richtlinie autorisieren kann, die in der Konfiguration angegeben ist. Der Autorisierungs-Manager für benutzerdefinierte Ansprüche besteht aus drei grundlegenden Komponenten: einer klasse, die von ClaimsAuthorizationManager der implementierung des managers abgeleitet wird, der -Klasse, die ResourceAction eine Ressource und eine Aktion koppelt, und einem Richtlinienleser, der die in der Konfigurationsdatei angegebene Richtlinie liest und kompiliert. Diese kompilierte Richtlinie kann dann vom Berechtigungsautorisierungs-Manager verwendet werden, um einen Prinzipal auszuwerten, um den Zugriff auf Ressourcen zu autorisieren. Nicht alle Elemente werden der Kürze halber angezeigt. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Downloadmöglichkeiten finden Sie unter WIF-Codebeispielindex.

Der folgende Code zeigt die Überschreibung der LoadCustomConfiguration -Methode. Diese Methode verwendet eine Hilfsrichtlinienleserklasse (nicht angezeigt), um autorisierungsrichtlinien zu lesen und zu kompilieren, die in der Konfigurationsdatei angegeben sind. Richtlinien werden einem Wörterbuch hinzugefügt und von einem ResourceAction Schlüsselobjekt aufgerufen, das aus der Ressource und Aktion erstellt wird, für die sie vorgesehen sind.

static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
PolicyReader _policyReader = new PolicyReader();

/// <summary>
/// Overloads  the base class method to load the custom policies from the config file
/// </summary>
/// <param name="nodelist">XmlNodeList containing the policy information read from the config file</param>
public override void LoadCustomConfiguration(XmlNodeList nodelist)
{
    Expression<Func<ClaimsPrincipal, bool>> policyExpression;

    foreach (XmlNode node in nodelist)
    {
        //
        // Initialize the policy cache
        //
        XmlDictionaryReader rdr = XmlDictionaryReader.CreateDictionaryReader(new XmlTextReader(new StringReader(node.OuterXml)));
        rdr.MoveToContent();

        string resource = rdr.GetAttribute("resource");
        string action = rdr.GetAttribute("action");

        policyExpression = _policyReader.ReadPolicy(rdr);

        //
        // Compile the policy expression into a function
        //
        Func<ClaimsPrincipal, bool> policy = policyExpression.Compile();

        //
        // Insert the policy function into the policy cache
        //
        _policies[new ResourceAction(resource, action)] = policy;
    }
}

Der folgende Code zeigt die Klasse, die ResourceAction vom benutzerdefinierten Anspruchs-Manager verwendet wird.

using System;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Class to encapsulate resource/action pair
    /// </summary>
    public class ResourceAction
    {
        public string Resource;
        public string Action;

        /// <summary>
        /// Checks if the current instance is equal to the given object by comparing the resource and action values
        /// </summary>
        /// <param name="obj">object to compare to</param>
        /// <returns>True if equal, else false.</returns>
        public override bool Equals(object obj)
        {
            ResourceAction ra = obj as ResourceAction;
            if (ra != null)
            {
                return ((string.Compare(ra.Resource, Resource, true) == 0) && (string.Compare(ra.Action, Action, true) == 0));
            }

            return base.Equals(obj);
        }

        /// <summary>
        /// Gets the hash code.
        /// </summary>
        /// <returns>The hash code.</returns>
        public override int GetHashCode()
        {
            return (Resource + Action).ToLower().GetHashCode();
        }

        /// <summary>
        /// Creates an instance of ResourceAction class.
        /// </summary>
        /// <param name="resource">The resource name.</param>
        /// <param name="action">The action.</param>
        /// <exception cref="ArgumentNullException">when <paramref name="resource"/> is null</exception>
        public ResourceAction(string resource, string action)
        {
            if (string.IsNullOrEmpty(resource))
            {
                throw new ArgumentNullException("resource");
            }

            Resource = resource;
            Action = action;
        }
    }
}

Die vom Berechtigungsautorisierungs-Manager verwendete Richtlinie wird von benutzerdefinierten <policy> Elementen unter dem <claimsAuthorizationManager-Element> angegeben. Diese Richtlinie wird von der LoadCustomConfiguration -Methode gelesen und kompiliert. In der ersten Richtlinie muss der Prinzipal über einen der angegebenen Ansprüche verfügen, um die angegebene Aktion für die angegebene Ressource auszuführen. In der zweiten Richtlinie muss der Prinzipal über beide Ansprüche verfügen, um die angegebene Aktion für die angegebene Ressource ausführen zu können. In allen anderen wird dem Prinzipal automatisch zugriff gewährt, unabhängig von den Ansprüchen, die er besitzt.

<system.identityModel>
  <identityConfiguration>
    <claimsAuthorizationManager type="ClaimsAuthorizationLibrary.MyClaimsAuthorizationManager, ClaimsAuthorizationLibrary">
      <policy resource="http://localhost:28491/Developers.aspx" action="GET">
        <or>
          <claim claimType="http://schemas.microsoft.com/ws/2008/06/identity/claims/role" claimValue="developer" />
          <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
        </or>
      </policy>
      <policy resource="http://localhost:28491/Administrators.aspx" action="GET">
        <and>
          <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
          <claim claimType="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country" claimValue="USA" />
        </and>
      </policy>
      <policy resource="http://localhost:28491/Default.aspx" action="GET">
      </policy>
      <policy resource="http://localhost:28491/" action="GET">
      </policy>
      <policy resource="http://localhost:28491/Claims.aspx" action="GET">
      </policy>
    </claimsAuthorizationManager>

    ...

  </identityConfiguration>
</system.identityModel>

Hinweise

Die LoadCustomConfiguration -Methode wird von der Konfigurationsinfrastruktur aufgerufen. Wenn diese Methode aufgerufen wird, enthält die nodelist untergeordneten Elemente der obersten Ebene des <claimsAuthorizationManager-Elements> aus der Konfigurationsdatei. Jedes dieser Elemente kann wiederum Attribute oder untergeordnete Elemente enthalten, abhängig vom Konfigurationsschema, das Sie für Ihre abgeleitete Klasse definieren. Wenn unter dem Element in der <claimsAuthorizationManager> Konfigurationsdatei keine untergeordneten Elemente angezeigt werden, wird diese Methode nicht aufgerufen.

Die Standardimplementierung löst einen aus NotImplementedException. Überschreiben Sie diese Methode in Ihrer abgeleiteten Klasse, um die Initialisierung Ihres Anspruchsautorisierungs-Managers aus einer Konfigurationsdatei zu ermöglichen. In der Regel werden die Konfigurationselemente verwendet, um eine Autorisierungsrichtlinie auszudrücken. Sie können Jedoch Elemente definieren und auf eine beliebige Weise verwenden, die basierend auf den Anforderungen Ihrer Anwendung sinnvoll ist.

Gilt für: