ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Quando sottoposto a override in una classe derivata, carica la configurazione personalizzata dall'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)

Parametri

nodelist: XmlNodeList

Elementi di configurazione personalizzati. Ogni nodo nell'elenco è del tipo XmlElement.

Implementazioni

LoadCustomConfiguration(XmlNodeList)

Esempio

Gli esempi di codice usati negli ClaimsAuthorizationManager argomenti sono tratti dall'esempio Claims Based Authorization . Questo esempio fornisce un gestore di autorizzazioni delle attestazioni personalizzato che può autorizzare soggetti in base a un criterio specificato nella configurazione. Il gestore di autorizzazioni delle attestazioni personalizzate è costituito da tre componenti di base: una classe derivata da ClaimsAuthorizationManager che implementa il gestore, la ResourceAction classe che associa una risorsa e un'azione e un lettore di criteri che legge e compila i criteri specificati nel file di configurazione. Questo criterio compilato può quindi essere usato dal gestore delle autorizzazioni delle attestazioni per valutare un'entità per autorizzare l'accesso alle risorse. Non tutti gli elementi vengono visualizzati per brevità. Per informazioni su questo esempio e altri esempi disponibili per WIF e su dove scaricarli, vedere Indice di esempio di codice WIF.

Nel codice seguente viene illustrato l'override del LoadCustomConfiguration metodo . Questo metodo usa una classe di lettura dei criteri helper (non visualizzata) per leggere e compilare i criteri di autorizzazione specificati nel file di configurazione. I criteri vengono aggiunti a un dizionario e sono accessibili da un ResourceAction oggetto chiave creato dalla risorsa e dall'azione per cui sono destinati.

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

Il codice seguente mostra la ResourceAction classe usata dal gestore delle attestazioni personalizzate.


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

I criteri usati dal gestore di autorizzazione delle attestazioni vengono specificati da elementi personalizzati <policy> nell'elemento <claimsAuthorizationManager> . Questo criterio viene letto e compilato dal LoadCustomConfiguration metodo . Nel primo criterio, l'entità deve possedere una delle attestazioni specificate per eseguire l'azione specificata sulla risorsa specificata. Nel secondo criterio, l'entità deve possedere entrambe le attestazioni per poter eseguire l'azione specificata sulla risorsa specificata. In tutti gli altri, all'entità viene concesso automaticamente l'accesso indipendentemente dalle attestazioni che possiede.

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

Commenti

Il LoadCustomConfiguration metodo viene chiamato dall'infrastruttura di configurazione. Quando questo metodo viene chiamato, conterrà nodelist gli elementi figlio di primo livello dell'elemento <claimsAuthorizationManager> dal file di configurazione. Ognuno di questi elementi può, a sua volta, contenere attributi o elementi figlio a seconda dello schema di configurazione definito per la classe derivata. Se non vengono visualizzati elementi figlio sotto l'elemento <claimsAuthorizationManager> nel file di configurazione, questo metodo non viene chiamato.

L'implementazione predefinita genera un'eccezione NotImplementedException. Eseguire l'override di questo metodo nella classe derivata per abilitare l'inizializzazione del gestore autorizzazioni delle attestazioni da un file di configurazione. In genere, gli elementi di configurazione vengono usati per esprimere un criterio di autorizzazione; Tuttavia, è possibile definire gli elementi e usarli in qualsiasi modo appropriato in base ai requisiti dell'applicazione.

Si applica a

Share via