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

CodeAccessPermission (Clase)

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

System.Object
  System.Security.CodeAccessPermission
    Más...

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
[SecurityPermissionAttribute(SecurityAction.InheritanceDemand, ControlEvidence = true, 
	ControlPolicy = true)]
public abstract class CodeAccessPermission : IPermission, 
	ISecurityEncodable, IStackWalk

El tipo CodeAccessPermission expone los siguientes miembros.

  NombreDescripción
Método protegidoCodeAccessPermissionInicializa una nueva instancia de la clase CodeAccessPermission.
Arriba

  NombreDescripción
Método públicoAssertDeclara que el código de llamada puede tener acceso al recurso protegido mediante una petición de permiso a través del código que llama a este método, aunque los llamadores que se encuentran en una posición superior de la pila no dispongan de permiso de acceso al recurso. La utilización de Assert puede crear problemas de seguridad.
Método públicoCopyCuando se implementa mediante una clase derivada, crea y devuelve una copia idéntica del objeto de permiso actual.
Método públicoDemandFuerza SecurityException en tiempo de ejecución si todos los llamadores situados en la pila de llamadas no disponen del permiso especificado por la instancia actual.
Método públicoDeny Obsoleta. Evita que los llamadores situados en la parte superior de la pila de llamadas utilicen el código que llama a este método para obtener acceso al recurso especificado por la instancia actual.
Método públicoEqualsDetermina si el objeto CodeAccessPermission especificado es igual al objeto CodeAccessPermission actual. (Invalida a Object.Equals(Object)).
Método protegidoFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoFromXmlCuando se reemplaza en una clase derivada, reconstruye un objeto de seguridad con un estado especificado a partir de codificación XML.
Método públicoGetHashCodeObtiene un código hash para el objeto CodeAccessPermission que sea compatible con los algoritmos hash y estructuras de datos como las tablas hash. (Invalida a Object.GetHashCode()).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoIntersectCuando 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.
Método públicoIsSubsetOfCuando se implementa mediante una clase derivada, determina si el permiso actual es un subconjunto del permiso especificado.
Método protegidoMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoPermitOnlyEvita que los llamadores situados en la parte superior de la pila de llamadas utilicen el código que llama a este método para obtener acceso a todos los recursos con la excepción del recurso especificado por la instancia actual.
Método públicoMiembro estáticoRevertAllHace que se quiten todos los reemplazos anteriores del marco actual y que ya no estén activos.
Método públicoMiembro estáticoRevertAssertHace que se eliminen todos los métodos Assert anteriores del marco actual y que dejen de estar en vigor.
Método públicoMiembro estáticoRevertDeny Obsoleta. Hace que se eliminen todos los métodos Deny anteriores del marco actual y que dejen de estar en vigor.
Método públicoMiembro estáticoRevertPermitOnlyHace que se eliminen todas las acciones PermitOnly anteriores del marco actual y que dejen de estar en vigor.
Método públicoToStringCrea y devuelve una cadena que representa el objeto de permiso actual. (Invalida a Object.ToString()).
Método públicoToXmlCuando se reemplaza en una clase derivada, se crea codificación XML del objeto de seguridad y de su estado actual.
Método públicoUnionCuando se reemplaza en una clase derivada, se crea un permiso que es la unión del permiso actual y del permiso especificado.
Arriba

Los permisos de acceso al código utilizan un recorrido por la pila con el fin de garantizar que se conceda un permiso a todos los llamadores del código. Si un objeto de permiso es null, se controla de la misma forma que un objeto de permiso con el estado PermissionState.None.

La pila de llamadas suele representarse de forma decreciente, por lo que los métodos que se encuentran en las posiciones superiores de la pila de llamadas, llaman a métodos de las posiciones inferiores.

Se debe conceder a los herederos de la clase CodeAccessPermission plena confianza para que funcionen correctamente como permisos que extienden la infraestructura de seguridad. Para determinar que los herederos son de plena confianza, CodeAccessPermission emite un campo InheritanceDemand para ControlEvidence = true y ControlPolicy = true.

Para obtener más información sobre las peticiones de herencia, vea Peticiones de herencia.

Notas para los herederos

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

Deben reemplazarse los miembros de CodeAccessPermission siguientes: Copy, Intersect, IsSubsetOf, ToXml, FromXml y Union.

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

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

El ejemplo de código siguiente muestra un permiso derivado de la clase CodeAccessPermission.


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


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, 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.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

System.Object
  System.Security.CodeAccessPermission
    System.Configuration.ConfigurationPermission
    System.Data.Common.DBDataPermission
    System.Data.OracleClient.OraclePermission
    System.Drawing.Printing.PrintingPermission
    System.Messaging.MessageQueuePermission
    System.Net.DnsPermission
    System.Net.Mail.SmtpPermission
    System.Net.NetworkInformation.NetworkInformationPermission
    System.Net.PeerToPeer.Collaboration.PeerCollaborationPermission
    System.Net.PeerToPeer.PnrpPermission
    System.Net.SocketPermission
    System.Net.WebPermission
    System.Security.Permissions.DataProtectionPermission
    System.Security.Permissions.EnvironmentPermission
    System.Security.Permissions.FileDialogPermission
    System.Security.Permissions.FileIOPermission
    System.Security.Permissions.GacIdentityPermission
    System.Security.Permissions.IsolatedStoragePermission
    System.Security.Permissions.KeyContainerPermission
    System.Security.Permissions.MediaPermission
    System.Security.Permissions.PublisherIdentityPermission
    System.Security.Permissions.ReflectionPermission
    System.Security.Permissions.RegistryPermission
    System.Security.Permissions.ResourcePermissionBase
    System.Security.Permissions.SecurityPermission
    System.Security.Permissions.SiteIdentityPermission
    System.Security.Permissions.StorePermission
    System.Security.Permissions.StrongNameIdentityPermission
    System.Security.Permissions.TypeDescriptorPermission
    System.Security.Permissions.UIPermission
    System.Security.Permissions.UrlIdentityPermission
    System.Security.Permissions.WebBrowserPermission
    System.Security.Permissions.ZoneIdentityPermission
    System.Transactions.DistributedTransactionPermission
    System.Web.AspNetHostingPermission
    System.Xaml.Permissions.XamlLoadPermission

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft