Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Classe CodeAccessPermission

 

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

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

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

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

NomeDescrição
System_CAPS_protmethodCodeAccessPermission()

Inicializa uma nova instância da classe CodeAccessPermission.

NomeDescrição
System_CAPS_pubmethodAssert()

Declara que o código de chamada pode acessar o recurso protegido por uma demanda de permissão por meio do código que chama esse método, mesmo que os chamadores na pilha não recebeu permissão para acessar o recurso. Usando Assert pode criar problemas de segurança.

System_CAPS_pubmethodCopy()

Quando implementado por uma classe derivada, cria e retorna uma cópia idêntica do objeto de permissão atual.

System_CAPS_pubmethodDemand()

Força uma SecurityException em tempo de execução se todos os chamadores na pilha de chamadas não recebeu a permissão especificada na instância atual.

System_CAPS_pubmethodDeny()

Obsoleto.Impede que os chamadores na pilha de chamadas usando o código que chama esse método para acessar o recurso especificado pela instância atual.

System_CAPS_pubmethodEquals(Object)

Determina se o especificado CodeAccessPermission objeto é igual a atual CodeAccessPermission.(Substitui o Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)

System_CAPS_pubmethodFromXml(SecurityElement)

Quando substituído em uma classe derivada, reconstrói um objeto de segurança com um estado de uma codificação de XML especificado.

System_CAPS_pubmethodGetHashCode()

Obtém um código hash para o CodeAccessPermission objeto que é adequado para uso em algoritmos e estruturas de dados como uma tabela de hash de hash.(Substitui o Object.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_pubmethodIntersect(IPermission)

Quando implementado por uma classe derivada, cria e retorna uma permissão que é a interseção de permissão atual e a permissão especificada.

System_CAPS_pubmethodIsSubsetOf(IPermission)

Quando implementado por uma classe derivada, determina se a permissão atual é um subconjunto de permissão especificada.

System_CAPS_protmethodMemberwiseClone()

Cria uma cópia superficial do atual Object.(Herdado de Object.)

System_CAPS_pubmethodPermitOnly()

Impede que os chamadores na pilha de chamadas usando o código que chama esse método para acessar todos os recursos, exceto o recurso especificado pela instância atual.

System_CAPS_pubmethodSystem_CAPS_staticRevertAll()

Faz com que todas as substituições anteriores para o quadro atual a ser removido e não mais em vigor.

System_CAPS_pubmethodSystem_CAPS_staticRevertAssert()

Faz com que qualquer Assert para o quadro atual a ser removido e não mais em vigor.

System_CAPS_pubmethodSystem_CAPS_staticRevertDeny()

Obsoleto.Faz com que qualquer Deny para o quadro atual a ser removido e não mais em vigor.

System_CAPS_pubmethodSystem_CAPS_staticRevertPermitOnly()

Faz com que qualquer PermitOnly para o quadro atual a ser removido e não mais em vigor.

System_CAPS_pubmethodToString()

Cria e retorna uma representação de cadeia de caracteres do objeto de permissão atual.(Substitui o Object.ToString().)

System_CAPS_pubmethodToXml()

Quando substituído em uma classe derivada, cria uma codificação de XML do objeto de segurança e seu estado atual.

System_CAPS_pubmethodUnion(IPermission)

Quando substituído em uma classe derivada, cria uma permissão que é a união de permissão atual e a permissão especificada.

Permissões de acesso de código usam uma movimentação de pilha para garantir que todos os chamadores do código receberam uma permissão. Se for um objeto de permissão null, ela é tratada da mesma maneira como um objeto de permissão com o estado PermissionState.None.

A pilha de chamadas é representada geralmente como crescimento, para que mais alto na pilha de chamadas de métodos chamam métodos inferior na pilha de chamadas.

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

Observações para os Herdeiros:

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

O seguinte CodeAccessPermission membros devem ser substituídos: Copy, Intersect, IsSubsetOf, ToXml, FromXml, e Union.

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

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

O exemplo de código a seguir mostra uma permissão que deriva 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;
        }
     }
}

InheritanceDemand

for the ability of inheritors to provide evidence and view and modify policy. Associated enumerations: F:System.Security.Permissions.SecurityPermissionFlag.ControlEvidence, F:System.Security.Permissions.SecurityPermissionFlag.ControlPolicy.

.NET Framework
Disponível desde 1.1

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

Retornar ao início
Mostrar: