ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Metoda

Definice

Obor názvů:

System.Security.Claims

Sestavení:

System.IdentityModel.dll

Při přepsání v odvozené třídě načte vlastní konfiguraci z XML.

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)

Parametry

nodelist

XmlNodeList

Vlastní elementy konfigurace. Každý uzel v seznamu je typu XmlElement.

Implementuje

LoadCustomConfiguration(XmlNodeList)

Příklady

Příklady kódu používané v ClaimsAuthorizationManager tématech jsou převzaty z ukázky Claims Based Authorization . Tato ukázka poskytuje vlastního správce autorizace deklarací identity, který může autorizovat předměty na základě zásad zadaných v konfiguraci. Správce autorizace vlastních deklarací identity se skládá ze tří základních komponent: třídy odvozené od ClaimsAuthorizationManager toho, která implementuje správce, třídu, ResourceAction která spáruje prostředek a akci, a čtenář zásad, který čte a kompiluje zásady zadané v konfiguračním souboru. Tuto kompilovanou zásadu pak může správce autorizace deklarací použít k vyhodnocení objektu zabezpečení, aby mohl autorizovat přístup k prostředkům. Ne všechny prvky se zobrazují kvůli stručnosti.

Následující kód ukazuje přepsání LoadCustomConfiguration metody. Tato metoda používá třídu čtečky pomocných zásad (nezobrazuje se) ke čtení a kompilaci zásad autorizace zadaných v konfiguračním souboru. Zásady jsou přidány do slovníku a jsou přístupné pomocí klíčového ResourceAction objektu, který je vytvořen z prostředku a akce, pro kterou jsou určeny.

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

Následující kód ukazuje ResourceAction třídu používanou vlastním správcem deklarací identity.

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

Zásady používané správcem autorizace deklarací identity jsou určeny vlastními <policy> prvky v rámci <claimsAuthorizationManager> elementu. Tato zásada se čte a kompiluje metodou LoadCustomConfiguration . V první zásadě musí objekt zabezpečení mít jednu ze zadaných deklarací identity, aby mohl provést zadanou akci u zadaného prostředku. Ve druhé zásadě musí objekt zabezpečení obsahovat obě deklarace identity, aby bylo možné provést zadanou akci se zadaným prostředkem. Ve všech ostatních je objekt zabezpečení automaticky udělen přístup bez ohledu na nároky, které vlastní.

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

Poznámky

Metoda LoadCustomConfiguration je volána konfigurační infrastrukturou. Při zavolání nodelist této metody bude obsahovat podřízené elementy <nejvyšší úrovně claimsAuthorizationManager> z konfiguračního souboru. Každý z těchto prvků může zase obsahovat atributy nebo podřízené prvky v závislosti na schématu konfigurace, které definujete pro svoji odvozenou třídu. Pokud se pod elementem v konfiguračním <claimsAuthorizationManager> souboru nezobrazí žádné podřízené prvky, tato metoda není volána.

Výchozí implementace vyvolá výjimku NotImplementedException. Tuto metodu v odvozené třídě přepište, aby se povolila inicializace správce autorizace deklarací identity z konfiguračního souboru. Elementy konfigurace se obvykle používají k vyjádření zásad autorizace; můžete však definovat prvky a používat je jakýmkoli způsobem, který dává smysl na základě požadavků vaší aplikace.