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

Clase CodeAccessPermission

 

Publicado: octubre de 2016

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

Espacio de nombres:   System.Security
Ensamblado:  mscorlib (en 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 ref class CodeAccessPermission abstract : IPermission, 
	ISecurityEncodable, IStackWalk

NombreDescripción
System_CAPS_protmethodCodeAccessPermission()

Inicializa una nueva instancia de la clase CodeAccessPermission.

NombreDescripción
System_CAPS_pubmethodAssert()

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.

System_CAPS_pubmethodCopy()

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

System_CAPS_pubmethodDemand()

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.

System_CAPS_pubmethodDeny()

Obsoleto. 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.

System_CAPS_pubmethodEquals(Object^)

Determina si el objeto CodeAccessPermission especificado es igual al objeto CodeAccessPermission actual.(Invalida Object::Equals(Object^)).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodFromXml(SecurityElement^)

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

System_CAPS_pubmethodGetHashCode()

Obtiene un código hash para el objeto CodeAccessPermission que es adecuado para usarlo en algoritmos hash y las estructuras de datos, como una tabla hash.(Invalida Object::GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodIntersect(IPermission^)

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

System_CAPS_pubmethodIsSubsetOf(IPermission^)

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

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodPermitOnly()

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.

System_CAPS_pubmethodSystem_CAPS_staticRevertAll()

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

System_CAPS_pubmethodSystem_CAPS_staticRevertAssert()

Provoca que se elimine cualquier Assert anterior para el marco actual y que ya no esté en vigor.

System_CAPS_pubmethodSystem_CAPS_staticRevertDeny()

Obsoleto. Provoca que se elimine cualquier Deny anterior para el marco actual y que ya no esté en vigor.

System_CAPS_pubmethodSystem_CAPS_staticRevertPermitOnly()

Provoca que se elimine cualquier PermitOnly anterior para el marco actual y que ya no esté en vigor.

System_CAPS_pubmethodToString()

Crea y devuelve una representación de cadena del objeto de permiso actual.(Invalida Object::ToString()).

System_CAPS_pubmethodToXml()

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

System_CAPS_pubmethodUnion(IPermission^)

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

Code access permissions use a stack walk to ensure that all callers of the code have been granted a permission. If a permission object is null, it is handled the same as a permission object with the state F:System.Security.Permissions.PermissionState.None.

The call stack is typically represented as growing down, so that methods higher in the call stack call methods lower in the call stack.

Inheritors of the T:System.Security.CodeAccessPermission class must be granted full trust to function correctly as permissions extending the security infrastructure. To determine that the inheritors are fully trusted, T:System.Security.CodeAccessPermission issues an F:System.Security.Permissions.SecurityAction.InheritanceDemand for F:System.Security.Permissions.SecurityPermissionFlag.ControlEvidence = true and F:System.Security.Permissions.SecurityPermissionFlag.ControlPolicy = true.

Notas para desarrolladores de herederos:

When you inherit from T:System.Security.CodeAccessPermission, you must also implement the T:System.Security.Permissions.IUnrestrictedPermission interface.

The following T:System.Security.CodeAccessPermission members must be overridden: M:System.Security.CodeAccessPermission.Copy, M:System.Security.CodeAccessPermission.Intersect(System.Security.IPermission), M:System.Security.CodeAccessPermission.IsSubsetOf(System.Security.IPermission), M:System.Security.CodeAccessPermission.ToXml, M:System.Security.CodeAccessPermission.FromXml(System.Security.SecurityElement), and M:System.Security.CodeAccessPermission.Union(System.Security.IPermission).

You must also define a constructor that takes a T:System.Security.Permissions.PermissionState as its only parameter.

You must apply the T:System.SerializableAttribute attribute to a class that inherits from T:System.Security.CodeAccessPermission.

The following code example shows a permission derived from the T:System.Security.CodeAccessPermission class.

//#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 namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::IO;
using namespace System::Security::Policy;
using namespace System::Collections;
using namespace System::Text;

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

[Serializable]
public ref class NameIdPermission: public CodeAccessPermission, public IUnrestrictedPermission
{
private:
   String^ m_Name;
   bool m_Unrestricted;

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

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

   property String^ Name 
   {
      String^ get()
      {
         return m_Name;
      }
      void set( String^ value )
      {
         m_Name = value;
      }
   }

public:
   virtual IPermission^ Copy() override
   {
      String^ name = m_Name;
      return gcnew NameIdPermission( name );
   }

public:
   virtual bool IsUnrestricted()
   {
      // Always false, unrestricted state is not allowed.
      return m_Unrestricted;
   }

private:
   bool VerifyType( IPermission^ target )
   {
      return dynamic_cast<NameIdPermission^>(target) != nullptr;
   }

public:
   virtual bool IsSubsetOf( IPermission^ target ) override
   {
#if ( debug ) 
      Console::WriteLine( "************* Entering IsSubsetOf *********************" );
#endif

      if ( target == nullptr )
      {
         Console::WriteLine( "IsSubsetOf: target == null" );
         return false;
      }

#if ( debug ) 
      Console::WriteLine( "This is = {0}", ((NameIdPermission)this).Name );
      Console::WriteLine( "Target is {0}", ((NameIdPermission)target).m_Name );
#endif

      try
      {
         NameIdPermission^ operand = dynamic_cast<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 != nullptr )
         {
            if ( operand->m_Name == nullptr )
            {
               return false;
            }
            if ( this->m_Name->Equals( "" ) )
            {
               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 gcnew ArgumentException( String::Format( "Argument_WrongType", this->GetType()->FullName ) );
      }
   }

public:
   virtual IPermission^ Intersect( IPermission^ target ) override
   {
      Console::WriteLine( "************* Entering Intersect *********************" );
      if ( target == nullptr )
      {
         return nullptr;
      }

#if ( debug ) 
      Console::WriteLine( "This is = {0}", ((NameIdPermission)this).Name );
      Console::WriteLine( "Target is {0}", ((NameIdPermission)target).m_Name );
#endif 

      if (  !VerifyType( target ) )
      {
         throw gcnew ArgumentException( String::Format( "Argument is wrong type.", this->GetType()->FullName ) );
      }

      NameIdPermission^ operand = dynamic_cast<NameIdPermission^>(target);

      if ( operand->IsSubsetOf( this ) )
      {
         return operand->Copy();
      }
      else if ( this->IsSubsetOf( operand ) )
      {
         return this->Copy();
      }
      else
      {
         return nullptr;
      }
   }

public:
   virtual IPermission^ Union( IPermission^ target ) override
   {
#if ( debug ) 
      Console::WriteLine( "************* Entering Union *********************" );
#endif 

      if ( target == nullptr )
      {
         return this;
      }

#if ( debug ) 
      Console::WriteLine( "This is = {0}", ((NameIdPermission)this).Name );
      Console::WriteLine( "Target is {0}", ((NameIdPermission)target).m_Name );
#endif 

      if (  !VerifyType( target ) )
      {
         throw gcnew ArgumentException( String::Format( "Argument_WrongType", this->GetType()->FullName ) );
      }

      NameIdPermission^ operand = dynamic_cast<NameIdPermission^>(target);

      if ( operand->IsSubsetOf( this ) )
      {
         return this->Copy();
      }
      else if ( this->IsSubsetOf( operand ) )
      {
         return operand->Copy();
      }
      else
      {
         return nullptr;
      }
   }

public:
   virtual void FromXml( SecurityElement^ e ) override
   {
      // 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 ( nullptr != elUnrestricted )
      {
         m_Unrestricted = Boolean::Parse( elUnrestricted );
         return;
      }

      String^ elName = e->Attribute("Name");
      m_Name = elName == nullptr ? nullptr : elName;
   }

public:
   virtual SecurityElement^ ToXml() override
   {
      // Use the SecurityElement class to encode the permission to XML.
      SecurityElement^ esd = gcnew SecurityElement( "IPermission" );
      String^ name = NameIdPermission::typeid->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 != nullptr )
      {
         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
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: