Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original
Este tema aún no ha recibido ninguna valoración - Valorar este tema

IAuthorizationPolicy (Interfaz)

Define un conjunto de reglas para autorizar a un usuario, con un conjunto de demandas.

Espacio de nombres:  System.IdentityModel.Policy
Ensamblado:  System.IdentityModel (en System.IdentityModel.dll)
public interface IAuthorizationPolicy : IAuthorizationComponent

El tipo IAuthorizationPolicy expone los siguientes miembros.

  NombreDescripción
Propiedad públicaIdObtiene una cadena que identifica a este componente de autorización. (Se hereda de IAuthorizationComponent).
Propiedad públicaIssuerObtiene un conjunto de notificaciones que representa el emisor de la directiva de autorización.
Arriba
  NombreDescripción
Método públicoEvaluateevalúa si un usuario cumple los requisitos para esta directiva de autorización.
Arriba

Implemente la interfaz de IAuthorizationPolicy para agregar o para asignar un conjunto de demandas a otro. Una directiva de autorización examina un conjunto de demandas y agrega las demandas adicionales según el conjunto actual de. Por ejemplo, una directiva de autorización podría evaluar una demanda que contiene la fecha de nacimiento y agregar una demanda que declara que el usuario está durante 21 años y agregar una demanda Over21 a EvaluationContext.

Las clases que implementan la interfaz de IAuthorizationPolicy no está autorizado usuarios, pero las permiten a la clase de ServiceAuthorizationManager para ello. ServiceAuthorizationManager llama al método de Evaluate para cada directiva de autorización en vigor. El método de Evaluate determina si las demandas adicionales se deberían agregar para el usuario, según el contexto actual. El método de Evaluate de una directiva de autorización se puede llamar varias veces, como las demandas se agregan a EvaluationContext por otras directivas de autorización. Cuando todas las directivas de autorización en vigor se realizan, la clase de ServiceAuthorizationManager toma decisiones de autorización basadas en el conjunto final de demandas. La clase de ServiceAuthorizationManager crea AuthorizationContext que contiene un conjunto inmutable de demandas que refleje estas decisiones de autorización.


        public class MyAuthorizationPolicy : IAuthorizationPolicy
        {
            string id;

            public MyAuthorizationPolicy()
            {
                id =  Guid.NewGuid().ToString();
            }

            public bool Evaluate(EvaluationContext evaluationContext, ref object state)
            {
                bool bRet = false;
                CustomAuthState customstate = null;

                // If state is null, then this method has not been called before, so 
                // set up a custom state.
                if (state == null)
                {
                    customstate = new CustomAuthState();
                    state = customstate;
                }
                else
                    customstate = (CustomAuthState)state;

                Console.WriteLine("Inside MyAuthorizationPolicy::Evaluate");

                // If claims have not been added yet...
                if (!customstate.ClaimsAdded)
                {
                    // Create an empty list of Claims.
                    IList<Claim> claims = new List<Claim>();

                    // Iterate through each of the claim sets in the evaluation context.
                    foreach (ClaimSet cs in evaluationContext.ClaimSets)
                        // Look for Name claims in the current claim set.
                        foreach (Claim c in cs.FindClaims(ClaimTypes.Name, Rights.PossessProperty))
                            // Get the list of operations the given username is allowed to call.
                            foreach (string s in GetAllowedOpList(c.Resource.ToString()))
                            {
                                // Add claims to the list.
                                claims.Add(new Claim("http://example.org/claims/allowedoperation", s, Rights.PossessProperty));
                                Console.WriteLine("Claim added {0}", s);
                            }

                    // Add claims to the evaluation context.
                    evaluationContext.AddClaimSet(this, new DefaultClaimSet(this.Issuer,claims));

                    // Record that claims have been added.
                    customstate.ClaimsAdded = true;

                    // Return true, which indicates this need not be called again.
                    bRet = true;
                }
                else
                {
                    // This point should not be reached, but just in case...
                    bRet = true;
                }


                return bRet;
            }
            public ClaimSet Issuer
            {
                get { return ClaimSet.System; }
            }

            public string Id
            {
                get { return id; }
            }

            // This method returns a collection of action strings that indicate the 
            // operations that the specified username is allowed to call.
            private IEnumerable<string> GetAllowedOpList(string username)
            {
                IList<string> ret = new List<string>();

                if (username == "test1")
                {
                    ret.Add ( "http://Microsoft.ServiceModel.Samples/ICalculator/Add");
                    ret.Add ("http://Microsoft.ServiceModel.Samples/ICalculator/Multiply");
                    ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract");
                }
                else if (username == "test2")
                {
                    ret.Add ( "http://Microsoft.ServiceModel.Samples/ICalculator/Add");
                    ret.Add ("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract");
                }
                return ret;
            }

            // internal class for state
            class CustomAuthState
            {
                bool bClaimsAdded;

                public CustomAuthState()
                {
                    bClaimsAdded = false;
                }

                public bool ClaimsAdded { get { return bClaimsAdded; } 
                                          set {  bClaimsAdded = value; } }
            }
        }



.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft. Reservados todos los derechos.