Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método CodeAccessPermission.IsSubsetOf (IPermission)

 

Publicado: octubre de 2016

Cuando se implementa mediante una clase derivada, determina si el permiso actual es un subconjunto del permiso especificado.

Espacio de nombres:   System.Security
Ensamblado:  mscorlib (en mscorlib.dll)

public abstract bool IsSubsetOf(
	IPermission target
)

Parámetros

target
Type: System.Security.IPermission

Permiso que se va a probar para la relación de subconjunto. Este permiso debe ser del mismo tipo que el permiso actual.

Valor devuelto

Type: System.Boolean

true si el permiso actual es un subconjunto del permiso especificado; si no, false.

Exception Condition
ArgumentException

El parámetro target no es null y no es del mismo tipo que el permiso actual.

El permiso actual es un subconjunto del permiso especificado si el permiso actual especifica un conjunto de operaciones contenidas completo por el permiso especificado. Por ejemplo, un permiso que representa el acceso a C:\example.txt es un subconjunto de un permiso que representa el acceso a C:\. Si este método devuelve true, el permiso actual no representa ningún más acceso al recurso protegido que el permiso especificado.

Las instrucciones siguientes deben ser true para todas las invalidaciones de la IsSubsetOf (método). X, Y, y Z representan objetos de permiso de acceso a código personalizado que no son referencias nulas, U representa un permiso de acceso del código sin restricciones, y N representa un permiso vacío con un PermissionState de None.

  • X. IsSubsetOf (X) devuelve true.

  • X. IsSubsetOf (Y) devuelve el mismo valor que Y. IsSubsetOf (X) si y solo si X y Y representan el mismo conjunto de permisos.

  • If X. IsSubsetOf (Y) y Y. IsSubsetOf (Z) devuelven true, X. IsSubsetOf (Z) devuelve true.

  • X. IsSubsetOf (U) devuelve true.

  • X. IsSubsetOf (N) devuelve false.

  • N. IsSubsetOf (X) devuelve true.

Si X y Y representan objetos de permiso de acceso a código personalizado que son referencias nulas, X. IsSubsetOf (Y) devuelve true. Si Z también es null, compuesto de operación set X. Union (Y). IsSubsetOf (Z) también devuelve true porque la unión de dos permisos nulos es un permiso nulo.

Notas para desarrolladores de herederos:

Debe invalidar este método en una clase derivada.

En el ejemplo de código siguiente se muestra una invalidación de la IsSubsetOf (método). Este ejemplo de código forma parte de un ejemplo mayor proporcionado para el CodeAccessPermission clase.

        public override bool IsSubsetOf(IPermission target)
        {
#if(debug)
            Console.WriteLine ("************* Entering IsSubsetOf *********************");
#endif
            if (target == null)
            {
                Console.WriteLine ("IsSubsetOf: target == null");
                return false;
            }
#if(debug)

            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            try
            {
                 NameIdPermission operand = ( NameIdPermission)target;

                // The following check for unrestricted permission is only included as an example for
                // permissions that allow the unrestricted state. It is of no value for this permission.
                if (true == operand.m_Unrestricted)
                {
                    return true;
                }
                else if (true == this.m_Unrestricted)
                {
                    return false;
                }

                if (this.m_Name != null)
                {
                    if (operand.m_Name == null) return false;

                    if (this.m_Name == "") return true;
                }

                if (this.m_Name.Equals (operand.m_Name)) return true;
                else
                {
                    // Check for wild card character '*'.
                    int i = operand.m_Name.LastIndexOf ("*");

                    if (i > 0)
                    {
                        string prefix = operand.m_Name.Substring (0, i);

                        if (this.m_Name.StartsWith (prefix))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            catch (InvalidCastException)
            {
                throw new ArgumentException (String.Format ("Argument_WrongType", this.GetType ().FullName));
            }
        }

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: