ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Método

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)

Parâmetros

Implementações

Exemplos

Os exemplos de código usados nos ClaimsAuthorizationManager tópicos são retirados da Claims Based Authorization amostra. Este exemplo fornece um gestor personalizado de autorização de reclamações que pode autorizar os sujeitos com base numa política especificada na configuração. O gestor personalizado de autorização de reivindicações consiste em três componentes básicos: uma classe derivada de ClaimsAuthorizationManager que implementa o gestor, a ResourceAction classe que emparelha um recurso e uma ação, e um leitor de políticas que lê e compila a política especificada no ficheiro de configuração. Esta apólice compilada pode depois ser usada pelo gestor de autorização de sinistros para avaliar um principal e autorizar o acesso aos recursos. Nem todos os elementos são mostrados por brevidade. Para informações sobre esta amostra e outras amostras disponíveis para WIF e sobre onde as descarregar, consulte o Índice de Exemplos de Código WIF.

O código seguinte mostra a sobreposição do LoadCustomConfiguration método. Este método utiliza uma classe leitora de políticas auxiliar (não mostrada) para ler e compilar políticas de autorização especificadas no ficheiro de configuração. As políticas são adicionadas a um dicionário e acedidas por um ResourceAction objeto-chave criado a partir do recurso e da ação para os quais se destinam.

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

O código seguinte mostra a ResourceAction classe usada pelo gestor personalizado de sinistros.

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

A apólice utilizada pelo gestor de autorização de reclamações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Esta política é lida e compilada pelo LoadCustomConfiguration método. Na primeira apólice, o principal deve possuir uma das reivindicações especificadas para realizar a ação especificada sobre o recurso especificado. Na segunda apólice, o principal deve possuir ambas as reivindicações para poder realizar a ação especificada sobre o recurso especificado. Em todas as outras, o principal recebe acesso automaticamente independentemente das reivindicações que possui.

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

Observações

O LoadCustomConfiguration método é chamado pela infraestrutura de configuração. Quando este método é chamado, o nodelist irá conter os elementos filhos de topo do <elemento claimsAuthorizationManager> do ficheiro de configuração. Cada um destes elementos pode, por sua vez, conter atributos ou elementos filhos, dependendo do esquema de configuração que definir para a sua classe derivada. Se nenhum elemento filho aparecer sob o <claimsAuthorizationManager> elemento no ficheiro de configuração, este método não é chamado.

A implementação padrão gera um NotImplementedException. Substitua este método na sua classe derivada para permitir a inicialização do seu gestor de autorização de sinistros a partir de um ficheiro de configuração. Tipicamente, os elementos de configuração são usados para expressar uma política de autorização; No entanto, podes definir elementos e usá-los da forma que fizer sentido, consoante os requisitos da tua aplicação.