ClaimsAuthorizationManager.LoadCustomConfiguration(XmlNodeList) Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Security.Claims

Zestaw:: System.IdentityModel.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Po zastąpieniu w klasie pochodnej ładuje konfigurację niestandardową z pliku 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

Niestandardowe elementy konfiguracji. Każdy węzeł na liście ma typ XmlElement.

Implementuje

LoadCustomConfiguration(XmlNodeList)

Przykłady

Przykłady kodu używane w tematach ClaimsAuthorizationManager pochodzą z przykładu Claims Based Authorization . Ten przykład zawiera niestandardowego menedżera autoryzacji oświadczeń, który może autoryzować podmioty na podstawie zasad określonych w konfiguracji. Menedżer autoryzacji oświadczeń niestandardowych składa się z trzech podstawowych składników: klasy pochodnej z ClaimsAuthorizationManager niej, która implementuje menedżera, ResourceAction klasę, która łączy zasób i akcję, oraz czytnik zasad, który odczytuje i kompiluje zasady określone w pliku konfiguracji. Te skompilowane zasady mogą być następnie używane przez menedżera autoryzacji oświadczeń do oceny podmiotu zabezpieczeń w celu autoryzowania dostępu do zasobów. Nie wszystkie elementy są wyświetlane ze względu na zwięzłość. Aby uzyskać informacje o tym przykładzie i innych przykładach dostępnych dla programu WIF oraz o tym, gdzie je pobrać, zobacz Przykładowy indeks kodu programu WIF.

Poniższy kod przedstawia zastąpienie LoadCustomConfiguration metody . Ta metoda używa klasy czytnika zasad pomocnika (nie pokazano) do odczytywania i kompilowania zasad autoryzacji określonych w pliku konfiguracji. Zasady są dodawane do słownika i są dostępne przez ResourceAction obiekt klucza tworzony na podstawie zasobu i akcji, dla których są przeznaczone.

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

Poniższy kod przedstawia klasę ResourceAction używaną przez menedżera oświadczeń niestandardowych.


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

Zasady używane przez menedżera autoryzacji oświadczeń są określane przez elementy niestandardowe <policy> w <ramach elementu claimsAuthorizationManager> . Te zasady są odczytywane i kompilowane przez metodę LoadCustomConfiguration . W pierwszych zasadach podmiot zabezpieczeń musi posiadać jedno z określonych oświadczeń, aby wykonać określoną akcję dla określonego zasobu. W drugiej zasadach podmiot zabezpieczeń musi posiadać oba oświadczenia, aby móc wykonać określoną akcję dla określonego zasobu. We wszystkich innych podmiotach podmiot zabezpieczeń jest automatycznie udzielany dostępu niezależnie od posiadanych przez nią roszczeń.

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

Uwagi

Metoda jest wywoływana LoadCustomConfiguration przez infrastrukturę konfiguracji. Po wywołaniu nodelist tej metody element będzie zawierać elementy podrzędne najwyższego <poziomu elementu claimsAuthorizationManager> z pliku konfiguracji. Każdy z tych elementów może z kolei zawierać atrybuty lub elementy podrzędne w zależności od schematu konfiguracji zdefiniowanego dla klasy pochodnej. Jeśli w pliku konfiguracji nie występują <claimsAuthorizationManager> żadne elementy podrzędne, ta metoda nie jest wywoływana.

Domyślna implementacja zgłasza błąd NotImplementedException. Zastąp tę metodę w klasie pochodnej, aby umożliwić inicjowanie menedżera autoryzacji oświadczeń z pliku konfiguracji. Zazwyczaj elementy konfiguracji są używane do wyrażania zasad autoryzacji; można jednak definiować elementy i używać ich w dowolny sposób, który ma sens na podstawie wymagań aplikacji.

Dotyczy

Udostępnij za pośrednictwem