Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe CodeAccessPermission

Define a estrutura subjacente de todas as permissões de acesso do código.

System.Object
  System.Security.CodeAccessPermission
    Mais...

Namespace:  System.Security
Assembly:  mscorlib (em mscorlib.dll)

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

O tipo CodeAccessPermission expõe os membros a seguir.

  NomeDescrição
Método protegidoCodeAccessPermissionInicializa uma nova instância da classe CodeAccessPermission.
Superior

  NomeDescrição
Método públicoAssertDeclara que o código de chamada pode acessar o recurso protegido por uma demanda de permissão através do código que chama esse método, mesmo se os chamadores superiores na pilha não receberam permissão para acessar o recurso. Usando Assert pode criar problemas de segurança.
Método públicoCopyQuando implementado por uma classe derivada, cria e retorna uma cópia idêntica do objeto de permissão atual.
Método públicoDemandForça uma SecurityException em tempo de execução se todos os chamadores superiores na pilha de chamada não foi concedidos a permissão especificada por instância atual.
Método públicoDeny Obsoleta. Impede que os chamadores superiores na pilha de chamadas usando o código que chama esse método para acessar o recurso especificado por instância atual.
Método públicoEqualsDetermina se o especificado CodeAccessPermission objeto é igual a atual CodeAccessPermission. (Substitui Object.Equals(Object).)
Método protegidoFinalize Permite um objeto tentar liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
Método públicoFromXmlQuando substituído em uma classe derivada, reconstrói um objeto de segurança com um estado especificado de uma codificação XML.
Método públicoGetHashCodeObtém um código de hash para o CodeAccessPermission objeto é adequado para uso em hash algoritmos e estruturas de dados como uma tabela de hash. (Substitui Object.GetHashCode().)
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoIntersectQuando implementado por uma classe derivada, cria e retorna uma permissão que é a interseção da permissão atual e a permissão especificada.
Método públicoIsSubsetOfQuando implementado por uma classe derivada, determina se a permissão atual é um subconjunto da permissão especificado.
Método protegidoMemberwiseCloneCria uma cópia superficial do Object atual. (Herdado de Object.)
Método públicoPermitOnlyImpede que os chamadores superiores na pilha de chamadas usando o código que chama esse método para acessar todos os recursos, exceto para o recurso especificado por instância atual.
Método públicoMembro estáticoRevertAllFaz com que todas as substituições anteriores para o quadro atual a ser removido e não mais em vigor.
Método públicoMembro estáticoRevertAssertFaz com que qualquer anterior Assert para o quadro atual a ser removido e não mais em vigor.
Método públicoMembro estáticoRevertDeny Obsoleta. Faz com que qualquer anterior Deny para o quadro atual a ser removido e não mais em vigor.
Método públicoMembro estáticoRevertPermitOnlyFaz com que qualquer anterior PermitOnly para o quadro atual a ser removido e não mais em vigor.
Método públicoToStringCria e retorna uma representação de seqüência de caracteres do objeto de permissão atual. (Substitui Object.ToString().)
Método públicoToXmlQuando substituído em uma classe derivada, cria uma codificação XML do objeto de segurança e estado atual.
Método públicoUnionQuando substituído em uma classe derivada, cria uma permissão que é a união da permissão atual e a permissão especificada.
Superior

As permissões de acesso usam um stack walk para garantir que todos os chamadores do código receberam uma permissão. Se for um objeto de permissão null, ele é tratado o mesmo que um objeto de permissão com o estado PermissionState.None.

A pilha de chamadas geralmente é representada como crescente para baixo, para que métodos superiores na pilha de chamadas chamam métodos inferior na pilha de chamadas.

Herdeiros do CodeAccessPermission classe deve receber confiança total para funcionar corretamente como estender a infra-estrutura de segurança de permissões. Para determinar que os herdeiros são totalmente confiáveis, CodeAccessPermission problemas de um InheritanceDemand para ControlEvidence = true e ControlPolicy = true.

Para obter mais informações sobre as demandas de herança, consulte Demandas de herança.

Observações para herdeiros

Quando você herdar de CodeAccessPermission, você também deve implementar o IUnrestrictedPermission interface.

The following CodeAccessPermission members must be overridden: Copy, Intersect, IsSubsetOf, ToXml, FromXml, and Union.

Você também deve definir um construtor que leva um PermissionState como seu único parâmetro.

Você deve aplicar o SerializableAttribute de atributo para uma classe que herda de CodeAccessPermission.

O exemplo de código a seguir mostra uma permissão derivada de CodeAccessPermission classe.


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

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Com suporte em: 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 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Quaisquer membros estático (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

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

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft