ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Methode

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)

Parameters

Implementeringen

Voorbeelden

De codevoorbeelden die in de ClaimsAuthorizationManager onderwerpen worden gebruikt, worden uit het Claims Based Authorization voorbeeld genomen. Dit voorbeeld biedt een aangepaste claimautorisatiebeheerder die onderwerpen kan autoriseren op basis van een beleid dat is opgegeven in de configuratie. De aangepaste claimautorisatiebeheer bestaat uit drie basisonderdelen: een klasse die is afgeleid van ClaimsAuthorizationManager die de manager implementeert, de ResourceAction klasse die een resource en een actie koppelt, en een beleidslezer die beleid leest en compileert dat is opgegeven in het configuratiebestand. Dit gecompileerde beleid kan vervolgens worden gebruikt door de claimautorisatiebeheerder om een principal te evalueren om toegang tot resources te autoriseren. Niet alle elementen worden omwille van de beknoptheid weergegeven. Zie de WIF-codevoorbeeldindex voor informatie over dit voorbeeld en andere voorbeelden die beschikbaar zijn voor WIF en waar u ze kunt downloaden.

De volgende code toont de onderdrukking van de LoadCustomConfiguration methode. Deze methode maakt gebruik van een helperbeleidslezerklasse (niet weergegeven) voor het lezen en compileren van autorisatiebeleid dat is opgegeven in het configuratiebestand. Beleidsregels worden toegevoegd aan een woordenlijst en worden geopend door een ResourceAction sleutelobject dat is gemaakt op basis van de resource en actie waarvoor ze zijn bedoeld.

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

De volgende code toont de ResourceAction klasse die wordt gebruikt door de aangepaste claimbeheerder.

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

Het beleid dat wordt gebruikt door claimautorisatiebeheer, wordt opgegeven door aangepaste <policy> elementen onder het <element claimsAuthorizationManager> . Dit beleid wordt gelezen en gecompileerd door de LoadCustomConfiguration methode. In het eerste beleid moet de principal een van de opgegeven claims bezitten om de opgegeven actie uit te voeren op de opgegeven resource. In het tweede beleid moet de principal beide claims bezitten om de opgegeven actie op de opgegeven resource uit te voeren. In alle andere wordt de principal automatisch toegang verleend, ongeacht de claims die de principal bezit.

<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>

Opmerkingen

De LoadCustomConfiguration methode wordt aangeroepen door de configuratie-infrastructuur. Wanneer deze methode wordt aangeroepen, bevat deze nodelist de onderliggende elementen op het hoogste niveau van het <element claimsAuthorizationManager> uit het configuratiebestand. Elk van deze elementen kan op zijn beurt kenmerken of onderliggende elementen bevatten, afhankelijk van het configuratieschema dat u definieert voor uw afgeleide klasse. Als er geen onderliggende elementen worden weergegeven onder het <claimsAuthorizationManager> element in het configuratiebestand, wordt deze methode niet aangeroepen.

De standaardimplementatie genereert een NotImplementedException. Overschrijf deze methode in uw afgeleide klasse om initialisatie van uw claimautorisatiebeheer in te schakelen vanuit een configuratiebestand. Normaal gesproken worden de configuratie-elementen gebruikt om een autorisatiebeleid uit te drukken; U kunt echter elementen definiëren en gebruiken op elke manier die zinvol is op basis van de vereisten van uw toepassing.