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 obtidos do Claims Based Authorization exemplo. Este exemplo fornece um gerenciador de autorização de declarações personalizado que pode autorizar assuntos com base em uma política especificada na configuração. O gerenciador de autorização de declarações personalizadas consiste em três componentes básicos: uma classe derivada ClaimsAuthorizationManager do que implementa o gerenciador, a ResourceAction classe que emparelha um recurso e uma ação e um leitor de política que lê e compila a política especificada no arquivo de configuração. Essa política compilada pode ser usada pelo gerenciador de autorização de declarações para avaliar uma entidade de segurança para autorizar o acesso aos recursos. Nem todos os elementos são mostrados para fins de brevidade. Para obter informações sobre este exemplo e outros exemplos disponíveis para WIF e sobre onde baixá-los, consulte o Índice de Exemplo de Código WIF.

O código a seguir mostra a substituição do LoadCustomConfiguration método. Esse método usa uma classe de leitor de política auxiliar (não mostrada) para ler e compilar políticas de autorização especificadas no arquivo de configuração. As políticas são adicionadas a um dicionário e são acessadas por um ResourceAction objeto de chave criado a partir do recurso e da ação para o qual 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 a seguir mostra a ResourceAction classe usada pelo gerenciador de declarações personalizado.

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 política usada pelo gerenciador de autorização de declarações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Essa política é lida e compilada pelo LoadCustomConfiguration método. Na primeira política, a entidade de segurança deve possuir uma das declarações especificadas para executar a ação especificada no recurso especificado. Na segunda política, a entidade de segurança deve possuir ambas as declarações para poder executar a ação especificada no recurso especificado. Em todos os outros, a entidade de segurança recebe automaticamente acesso, independentemente das declaraçõ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>

Comentários

O LoadCustomConfiguration método é chamado pela infraestrutura de configuração. Quando esse método for chamado, ele nodelist conterá os elementos filho de nível superior do <elemento claimsAuthorizationManager> do arquivo de configuração. Cada um desses elementos pode, por sua vez, conter atributos ou elementos filho, dependendo do esquema de configuração definido para sua classe derivada. Se nenhum elemento filho aparecer no <claimsAuthorizationManager> elemento no arquivo de configuração, esse método não será chamado.

A implementação padrão gera um NotImplementedException. Substitua esse método em sua classe derivada para habilitar a inicialização do gerenciador de autorização de declarações de um arquivo de configuração. Normalmente, os elementos de configuração são usados para expressar uma política de autorização; no entanto, você pode definir elementos e usá-los de qualquer maneira que faça sentido com base nos requisitos do seu aplicativo.

Aplica-se a