ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Méthode

Référence

Définition

Espace de noms:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Après substitution dans une classe dérivée, charge la configuration personnalisée à partir de 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)

Paramètres

nodelist: XmlNodeList

Éléments de configuration personnalisée. Chaque nœud de la liste est de type XmlElement.

Implémente

LoadCustomConfiguration(XmlNodeList)

Exemples

Les exemples de code utilisés dans les rubriques sont extraits de l’exemple ClaimsAuthorizationManager Claims Based Authorization . Cet exemple fournit un gestionnaire d’autorisation de revendications personnalisé qui peut autoriser des sujets basés sur une stratégie spécifiée dans la configuration. Le gestionnaire d’autorisation des revendications personnalisées se compose de trois composants de base : une classe dérivée qui ClaimsAuthorizationManager implémente le gestionnaire, la ResourceAction classe qui associe une ressource et une action, et un lecteur de stratégie qui lit et compile la stratégie spécifiée dans le fichier de configuration. Cette stratégie compilée peut ensuite être utilisée par le gestionnaire d’autorisations de revendications pour évaluer un principal afin d’autoriser l’accès aux ressources. Tous les éléments ne sont pas affichés pour la concision. Pour plus d’informations sur cet exemple et d’autres exemples disponibles pour WIF et sur l’emplacement de téléchargement, consultez l’exemple de code WIF.

Le code suivant montre le remplacement de la LoadCustomConfiguration méthode. Cette méthode utilise une classe de lecteur de stratégie d’assistance (non affichée) pour lire et compiler des stratégies d’autorisation spécifiées dans le fichier de configuration. Les stratégies sont ajoutées à un dictionnaire et sont accessibles par un ResourceAction objet clé créé à partir de la ressource et de l’action pour laquelle elles sont destinées.

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

Le code suivant montre la ResourceAction classe utilisée par le gestionnaire de revendications personnalisées.


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

La stratégie utilisée par le gestionnaire d’autorisation des revendications est spécifiée par des éléments personnalisés <policy> sous l’élément <claimsAuthorizationManager> . Cette stratégie est lue et compilée par la LoadCustomConfiguration méthode. Dans la première stratégie, le principal doit posséder l’une des revendications spécifiées pour effectuer l’action spécifiée sur la ressource spécifiée. Dans la deuxième stratégie, le principal doit posséder les deux revendications pour pouvoir effectuer l’action spécifiée sur la ressource spécifiée. Dans tous les autres, le principal est automatiquement autorisé à accéder, quelle que soit la revendication qu’il possède.

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

Remarques

La LoadCustomConfiguration méthode est appelée par l’infrastructure de configuration. Lorsque cette méthode est appelée, elle nodelist contient les éléments enfants de niveau supérieur de l’élément <claimsAuthorizationManager> à partir du fichier de configuration. Chacun de ces éléments peut, à son tour, contenir des attributs ou des éléments enfants en fonction du schéma de configuration que vous définissez pour votre classe dérivée. Si aucun élément enfant n’apparaît sous l’élément <claimsAuthorizationManager> du fichier de configuration, cette méthode n’est pas appelée.

L’implémentation par défaut lève un NotImplementedException. Remplacez cette méthode dans votre classe dérivée pour activer l’initialisation de votre gestionnaire d’autorisations de revendications à partir d’un fichier de configuration. En règle générale, les éléments de configuration sont utilisés pour exprimer une stratégie d’autorisation ; Toutefois, vous pouvez définir des éléments et les utiliser de toute façon qui est logique en fonction des exigences de votre application.

S’applique à