Leer en inglés

Compartir a través de

CodeAccessPermission Clase

  • Referencia

Definición

Espacio de nombres:
System.Security
Ensamblado:
System.Security.Permissions.dll
Ensamblado:
mscorlib.dll
Paquete:
System.Security.Permissions v6.0.0
Paquete:
System.Security.Permissions v7.0.0
Paquete:
System.Security.Permissions v8.0.0
Paquete:
System.Security.Permissions v9.0.0-preview.2.24128.5
Source:
CodeAccessPermission.cs
Source:
CodeAccessPermission.cs
Source:
CodeAccessPermission.cs

Precaución

Code Access Security is not supported or honored by the runtime.

Define la estructura subyacente de todos los permisos de acceso del código.

C# 
public abstract class CodeAccessPermission : System.Security.IPermission, System.Security.IStackWalk
C# 
[System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public abstract class CodeAccessPermission : System.Security.IPermission, System.Security.IStackWalk
C# 
[System.Serializable]
public abstract class CodeAccessPermission : System.Security.IPermission, System.Security.IStackWalk
C# 
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class CodeAccessPermission : System.Security.IPermission, System.Security.IStackWalk
Herencia
Object
CodeAccessPermission
Derivado
Atributos
ObsoleteAttribute SerializableAttribute ComVisibleAttribute
Implementaciones
IPermission ISecurityEncodable IStackWalk

Ejemplos

En el ejemplo de código siguiente se muestra un permiso derivado de la CodeAccessPermission clase .

C# 
//#define debug
// This custom permission is intended only for the purposes of illustration.
// The following code shows how to create a custom permission that inherits
// from CodeAccessPermission. The code implements all required overrides.
// A wildcard character ('*') is implemented for the Name property.
using System;
using System.Security;
using System.Security.Permissions;
using System.IO;
using System.Security.Policy;
using System.Collections;
using System.Text;

[assembly:System.Reflection.AssemblyKeyFile("Key.snk")]
[assembly:System.Security.AllowPartiallyTrustedCallersAttribute()]

namespace MyPermission
{
    [Serializable()] sealed public class   NameIdPermission : CodeAccessPermission, IUnrestrictedPermission
    {
        private String m_Name;
        private bool m_Unrestricted;

        public  NameIdPermission(String name)
        {
            m_Name = name;
        }

        public  NameIdPermission(PermissionState state)
        {
            if (state == PermissionState.None)
            {
                m_Name = "";
            }
            else
                if (state == PermissionState.Unrestricted)
            {
                throw new ArgumentException("Unrestricted state is not allowed for identity permissions.");
            }
            else
            {
                throw new ArgumentException("Invalid permission state.");
            }
        }

        public String Name
        {
            set{m_Name = value;}
            get{ return m_Name;}
        }
        public override IPermission Copy()
        {
            string name = m_Name;
            return new  NameIdPermission( name );
        }
        public bool IsUnrestricted()
        {
            // Always false, unrestricted state is not allowed.
            return m_Unrestricted;
        }

        private bool VerifyType(IPermission target)
        {
            return (target is  NameIdPermission);
        }
        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));
            }
        }
        public override IPermission Intersect(IPermission target)
        {
            Console.WriteLine ("************* Entering Intersect *********************");
            if (target == null)
            {
                return null;
            }
#if(debug)
            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            if (!VerifyType(target))
            {
                throw new ArgumentException (String.Format ("Argument is wrong type.", this.GetType ().FullName));
            }

             NameIdPermission operand = ( NameIdPermission)target;

            if (operand.IsSubsetOf (this)) return operand.Copy ();
            else if (this.IsSubsetOf (operand)) return this.Copy ();
            else
                return null;
        }

        public override IPermission Union(IPermission target)
        {
#if(debug)
            Console.WriteLine ("************* Entering Union *********************");
#endif
            if (target == null)
            {
                return this;
            }
#if(debug)
            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            if (!VerifyType(target))
            {
                throw new ArgumentException (String.Format ("Argument_WrongType", this.GetType ().FullName));
            }

             NameIdPermission operand = ( NameIdPermission)target;

            if (operand.IsSubsetOf (this)) return this.Copy ();
            else if (this.IsSubsetOf (operand)) return operand.Copy ();
            else
                return null;
        }
        
        
        
        
       public override void FromXml(SecurityElement e)
        {
            // The following code for unrestricted permission is only included as an example for
            // permissions that allow the unrestricted state. It is of no value for this permission.
            String elUnrestricted = e.Attribute("Unrestricted");
            if (null != elUnrestricted)
            {
                m_Unrestricted = bool.Parse(elUnrestricted);
                return;
            }

            String elName = e.Attribute( "Name" );
            m_Name = elName == null ? null : elName;
        }
        public override SecurityElement ToXml()
        {
            // Use the SecurityElement class to encode the permission to XML.
            SecurityElement esd = new SecurityElement("IPermission");
            String name = typeof( NameIdPermission).AssemblyQualifiedName;
            esd.AddAttribute("class", name);
            esd.AddAttribute("version", "1.0");

            // The following code 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 (m_Unrestricted)
            {
                esd.AddAttribute("Unrestricted", true.ToString());
            }
            if (m_Name != null) esd.AddAttribute( "Name", m_Name );
            return esd;
        }
     }
}

Comentarios

Precaución

La seguridad de acceso del código (CAS) ha quedado en desuso en todas las versiones de .NET Framework y .NET. Las versiones recientes de .NET no respetan las anotaciones de CAS y generan errores si se usan API relacionadas con CAS. Los desarrolladores deben buscar medios alternativos para realizar tareas de seguridad.

Los permisos de acceso al código usan un tutorial de pila para asegurarse de que a todos los autores de llamadas del código se les ha concedido un permiso. Si un objeto de permiso es null, se controla igual que un objeto de permiso con el estado PermissionState.None.

Normalmente, la pila de llamadas se representa como creciente, por lo que los métodos más altos en los métodos de llamada de la pila de llamadas se reducen en la pila de llamadas.

Los heredadores de la CodeAccessPermission clase deben tener plena confianza para funcionar correctamente como permisos que amplían la infraestructura de seguridad. Para determinar que los heredadores son de plena confianza, CodeAccessPermission emite un InheritanceDemand paratrue = ControlEvidence y .ControlPolicy = true

Notas a los implementadores

Cuando hereda de CodeAccessPermission, también debe implementar la IUnrestrictedPermission interfaz .

Los miembros siguientes CodeAccessPermission deben invalidarse: Copy(), Intersect(IPermission), IsSubsetOf(IPermission), ToXml(), FromXml(SecurityElement)y Union(IPermission).

También debe definir un constructor que tome como PermissionState único parámetro.

Debe aplicar el SerializableAttribute atributo a una clase que herede de CodeAccessPermission.

Constructores

CodeAccessPermission()
Obsoletos.

Inicializa una nueva instancia de la clase CodeAccessPermission.

Métodos

Assert()
Obsoletos.

Declara que el código de llamada puede tener acceso al recurso protegido por una demanda de permiso a través del código que llama a este método, incluso si los autores de la llamada situados en una posición más alta de la pila no tienen permiso para tener acceso al recurso. El uso de Assert() puede crear problemas de seguridad.
Copy()
Obsoletos.

Cuando se implementa mediante una clase derivada, crea y devuelve una copia idéntica del objeto de permiso actual.
Demand()
Obsoletos.

Fuerza a un SecurityException en tiempo de ejecución si todos los autores de llamada situados en la parte superior de la pila de llamadas no disponen del permiso especificado por la instancia actual.
Deny()
Obsoletos.
Obsoletos.

Impide que los autores de la llamada situados en la posición más alta de la pila de llamadas usen el código que llama a este método para tener acceso al recurso especificado por la instancia actual.
Equals(Object)
Obsoletos.

Determina si el objeto CodeAccessPermission especificado es igual al objeto CodeAccessPermission actual.
Equals(Object)
Obsoletos.

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
FromXml(SecurityElement)
Obsoletos.

Cuando se invalida en una clase derivada, reconstruye un objeto de seguridad con un estado especificado a partir de codificación XML.
GetHashCode()
Obsoletos.

Obtiene un código hash para el objeto CodeAccessPermission que es adecuado para su uso en algoritmos hash y estructuras de datos como una tabla hash.
GetHashCode()
Obsoletos.

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()
Obsoletos.

Obtiene el Type de la instancia actual.

(Heredado de Object)
Intersect(IPermission)
Obsoletos.

Cuando se implementa mediante una clase derivada, se crea y se devuelve un permiso que es la intersección del permiso actual y el permiso especificado.
IsSubsetOf(IPermission)
Obsoletos.

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

Crea una copia superficial del Object actual.

(Heredado de Object)
PermitOnly()
Obsoletos.

Impide que los llamadores situados más arriba en la pila de llamadas usen el código que llama a este método para tener acceso a todos los recursos excepto al recurso especificado por la instancia actual.
RevertAll()
Obsoletos.

Provoca que se eliminen todos los reemplazos anteriores del marco actual y que ya no estén en vigor.
RevertAssert()
Obsoletos.

Provoca que se elimine y deje de tener efecto cualquier Assert() anterior para el fotograma actual.
RevertDeny()
Obsoletos.
Obsoletos.

Provoca que se elimine y deje de tener efecto cualquier Deny() anterior para el fotograma actual.
RevertPermitOnly()
Obsoletos.

Provoca que se elimine y deje de tener efecto cualquier PermitOnly() anterior para el fotograma actual.
ToString()
Obsoletos.

Crea y devuelve una representación de cadena del objeto de permiso actual.
ToXml()
Obsoletos.

Cuando se invalida en una clase derivada, crea una codificación XML del objeto de seguridad y su estado actual.
Union(IPermission)
Obsoletos.

Cuando se invalida en una clase derivada, crea un permiso que es la unión del permiso actual y el permiso especificado.

Se aplica a

Producto Versiones (Obsoleto)
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
Windows Desktop 3.0, 3.1 (5, 6, 7, 8, 9)