TypeBuilder.AddDeclarativeSecurity-Methode

Artikel
08/20/2007

Fügt diesem Typ Deklarationssicherheit hinzu.

Namespace: System.Reflection.Emit
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Sub AddDeclarativeSecurity ( _
    action As SecurityAction, _
    pset As PermissionSet _
)
'Usage
Dim instance As TypeBuilder
Dim action As SecurityAction
Dim pset As PermissionSet

instance.AddDeclarativeSecurity(action, pset)

public void AddDeclarativeSecurity (
    SecurityAction action,
    PermissionSet pset
)

public:
void AddDeclarativeSecurity (
    SecurityAction action, 
    PermissionSet^ pset
)

public void AddDeclarativeSecurity (
    SecurityAction action, 
    PermissionSet pset
)

public function AddDeclarativeSecurity (
    action : SecurityAction, 
    pset : PermissionSet
)

Parameter

action
Die vorzunehmende Sicherheitsaktion, z. B. Demand, Assert usw.

pset
Der Berechtigungssatz, auf den die Aktion angewendet wird.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentOutOfRangeException	Die action ist ungültig (RequestMinimum, RequestOptional und RequestRefuse sind ungültig).
InvalidOperationException	Der enthaltende Typ wurde mit CreateType erstellt. - oder - Der Berechtigungssatz pset enthält eine Aktion, die bereits durch AddDeclarativeSecurity hinzugefügt wurde.
ArgumentNullException	pset ist NULL (Nothing in Visual Basic).

ArgumentOutOfRangeException

Die action ist ungültig (RequestMinimum, RequestOptional und RequestRefuse sind ungültig).

InvalidOperationException

Der enthaltende Typ wurde mit CreateType erstellt.

- oder -

Der Berechtigungssatz pset enthält eine Aktion, die bereits durch AddDeclarativeSecurity hinzugefügt wurde.

ArgumentNullException

pset ist NULL (Nothing in Visual Basic).

Hinweise

AddDeclarativeSecurity kann mehrmals aufgerufen werden, wobei jeder Aufruf eine Sicherheitsaktion (z. B. Demand, Assert oder Deny) und eine Gruppe von Berechtigungen angibt, die auf die Aktion angewendet werden.

Beispiel

Das folgende Codebeispiel veranschaulicht die Verwendung von AddDeclarativeSecurity zum Hinzufügen einer 'Demand'-Sicherheitsaktion zu einem dynamischen Typ.

Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security
Imports System.Security.Permissions

Namespace CustomAttribute_Sample

   Class MyApplication
      
      ' Create a dynamic type, MyDynamicClass, that demands
      ' ControlEvidence permission.
      '
      Private Shared Function CreateCallee(appDomain As AppDomain) As Type
         ' Create a simple name for the assembly.        
         Dim myAssemblyName As New AssemblyName()
         myAssemblyName.Name = "EmittedAssembly"
         ' Create the called dynamic assembly.
         Dim myAssemblyBuilder As AssemblyBuilder = _
                  appDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)
         Dim myModuleBuilder As ModuleBuilder = _
                  myAssemblyBuilder.DefineDynamicModule("EmittedModule")
         ' Define a public class named "MyDynamicClass" in the assembly.
         Dim myTypeBuilder As TypeBuilder = _
                  myModuleBuilder.DefineType("MyDynamicClass", TypeAttributes.Public)


         ' Create a permission set and add a security permission
         ' with the ControlEvidence flag.
         '
         Dim myPermissionSet As New PermissionSet(PermissionState.None)
         Dim ce As New SecurityPermission(SecurityPermissionFlag.ControlEvidence)
         myPermissionSet.AddPermission(ce)

         ' Add the permission set to the MyDynamicClass type,
         ' as a declarative security demand.
         '
         myTypeBuilder.AddDeclarativeSecurity(SecurityAction.Demand, myPermissionSet)


         ' Define a private String field named "m_greeting" in the type.
         Dim myFieldBuilder As FieldBuilder = _
                  myTypeBuilder.DefineField("m_greeting", GetType(String), FieldAttributes.Private)
         ' Define constructor.
         Dim constructorArgs() As Type = New Type() {GetType(String)}
         Dim myConstructorBuilder As ConstructorBuilder = _
                  myTypeBuilder.DefineConstructor(MethodAttributes.Public, _
                  CallingConventions.Standard, constructorArgs)
         ' Generate IL for the method.The constructor stores its argument in the private field.
         Dim constructorIL As ILGenerator = myConstructorBuilder.GetILGenerator()
         constructorIL.Emit(OpCodes.Ldarg_0)
         constructorIL.Emit(OpCodes.Ldarg_1)
         constructorIL.Emit(OpCodes.Stfld, myFieldBuilder)
         constructorIL.Emit(OpCodes.Ret)
         ' Define property 'Greeting'.
         Dim propertyArgs() As Type
         Dim myPropertyBuilder As PropertyBuilder = _
                  myTypeBuilder.DefineProperty("Greeting", PropertyAttributes.None, _
                  GetType(String), propertyArgs)
         ' Create the get_Greeting method.
         Dim getGreetingMethod As MethodBuilder = _
                  myTypeBuilder.DefineMethod("get_Greeting", MethodAttributes.Public Or _
                  MethodAttributes.HideBySig Or MethodAttributes.SpecialName, _
                  GetType(String), Nothing)
         ' Generate IL for get_Greeting method.
         Dim methodIL As ILGenerator = getGreetingMethod.GetILGenerator()
         methodIL.Emit(OpCodes.Ldarg_0)
         methodIL.Emit(OpCodes.Ldfld, myFieldBuilder)
         methodIL.Emit(OpCodes.Ret)
         myPropertyBuilder.SetGetMethod(getGreetingMethod)
         Dim myCustomClassType As Type = myTypeBuilder.CreateType()
         Return myCustomClassType
      End Function 'CreateCallee

      <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
      Public Shared Sub Main()
         Dim customClassType As Type = CreateCallee(Thread.GetDomain())

         Console.WriteLine("Trying to Create Instance with Default permission.")
         ' Create an instance of the "MyDynamicClass" class.
         Dim myCustomObject As Object = _
                  Activator.CreateInstance(customClassType, New Object() {"HelloWorld!!!"})
         ' Get the 'Greeting' property value.
         Dim objectGreeting As Object = _
                  customClassType.InvokeMember("Greeting", _
                  BindingFlags.GetProperty, Nothing, myCustomObject, Nothing)
         Console.WriteLine("Property Value: " & objectGreeting.ToString())
         Console.WriteLine("")


         ' Create a permission set that's the same as the set
         ' demanded by the MyDynamicClass class.
         '
         Dim myPermissionSet As New PermissionSet(PermissionState.None)
         Dim ce As New SecurityPermission(SecurityPermissionFlag.ControlEvidence)
         myPermissionSet.AddPermission(ce)

         ' Deny the permission set, and then try to create another
         ' instance of the MyDynamicClass class.
         '
         myPermissionSet.Deny()

         Console.WriteLine("Trying to Create Instance after permission has been denied.")
         Try
            ' Create an instance of the "MyDynamicClass" class.
            Dim myNewCustomObject As Object = _
                     Activator.CreateInstance(customClassType, New Object() {"HelloWorld!!!"})
         Catch e As Exception
            Console.WriteLine("Exception: Failed to create Instance")
            Console.WriteLine("'" & e.Message & "'")
         End Try
      End Sub 'Main
   End Class 'MyApplication
End Namespace 'CustomAttribute_Sample

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Security;
using System.Security.Permissions;

namespace CustomAttribute_Sample
{

   class MyApplication
   {
      // Create a dynamic type, MyDynamicClass, that demands
      // ControlEvidence permission.
      //
      private static Type CreateCallee(AppDomain appDomain)
      {
         // Create a simple name for the assembly.
         AssemblyName myAssemblyName = new AssemblyName();
         myAssemblyName.Name = "EmittedAssembly";
         // Create the called dynamic assembly.
         AssemblyBuilder myAssemblyBuilder =
            appDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run);
         ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("EmittedModule");
         // Define a public class named "MyDynamicClass" in the assembly.
         TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyDynamicClass",
            TypeAttributes.Public);


         // Create a permission set and add a security permission
         // with the ControlEvidence flag.
         //
         PermissionSet myPermissionSet = new PermissionSet(PermissionState.None);
         myPermissionSet.AddPermission(
             new SecurityPermission(SecurityPermissionFlag.ControlEvidence));

         // Add the permission set to the MyDynamicClass type,
         // as a declarative security demand.
         //
         myTypeBuilder.AddDeclarativeSecurity(SecurityAction.Demand, myPermissionSet);


         // Define a private String field named "m_greeting" in the type.
         FieldBuilder myFieldBuilder = myTypeBuilder.DefineField("m_greeting",
            typeof(String), FieldAttributes.Private);
         // Define constructor.
         Type[] constructorArgs = { typeof(String) };
         ConstructorBuilder myConstructorBuilder = myTypeBuilder.DefineConstructor(
            MethodAttributes.Public, CallingConventions.Standard, constructorArgs);
         // Generate IL for the method.The constructor stores its argument in the private field.
         ILGenerator constructorIL = myConstructorBuilder.GetILGenerator();
         constructorIL.Emit(OpCodes.Ldarg_0);
         constructorIL.Emit(OpCodes.Ldarg_1);
         constructorIL.Emit(OpCodes.Stfld, myFieldBuilder);
         constructorIL.Emit(OpCodes.Ret);
         // Define property 'Greeting'.
         Type[] propertyArgs = {};
         PropertyBuilder myPropertyBuilder = myTypeBuilder.DefineProperty("Greeting",
            PropertyAttributes.None, typeof(string),propertyArgs);
         // Create the get_Greeting method.
         MethodBuilder getGreetingMethod = myTypeBuilder.DefineMethod("get_Greeting",
            MethodAttributes.Public|MethodAttributes.HideBySig|MethodAttributes.SpecialName,
            typeof(String), null);
         // Generate IL for get_Greeting method.
         ILGenerator methodIL = getGreetingMethod.GetILGenerator();
         methodIL.Emit(OpCodes.Ldarg_0);
         methodIL.Emit(OpCodes.Ldfld, myFieldBuilder);
         methodIL.Emit(OpCodes.Ret);
         myPropertyBuilder.SetGetMethod(getGreetingMethod);
         Type myCustomClassType = myTypeBuilder.CreateType();
         return(myCustomClassType);
      }

      [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
      public static void Main()
      {
         Type customClassType = CreateCallee(Thread.GetDomain());
         Console.WriteLine("Trying to Create Instance with Default permission.");
         // Create an instance of the "MyDynamicClass" class.
         Object myCustomObject = Activator.CreateInstance(customClassType,
                                       new object[] {"HelloWorld!!!"});
         // Get 'Greeting' property.
         object objectGreeting =  customClassType.InvokeMember("Greeting",
            BindingFlags.GetProperty,
            null,
            myCustomObject,
            null);

         Console.WriteLine("Property Value: " + objectGreeting.ToString());
         Console.WriteLine("");


         // Create a permission set that's the same as the set
         // demanded by the MyDynamicClass class.
         //
         PermissionSet myPermissionSet = new PermissionSet(PermissionState.None);
         myPermissionSet.AddPermission(
             new SecurityPermission(SecurityPermissionFlag.ControlEvidence));

         // Deny the permission set, and then try to create another
         // instance of the MyDynamicClass class.
         //  
         myPermissionSet.Deny();

         Console.WriteLine("Trying to Create Instance after permission has been denied.");
         try
         {
             // Create an instance of the "MyDynamicClass" class.
             Object myNewCustomObject = Activator.CreateInstance(customClassType,
                                       new object[] {"HelloWorld!!!"});
         }
         catch( Exception e)
         {
            Console.WriteLine("Exception: Failed to create Instance");
            Console.WriteLine("'" + e.Message + "'");
         }
      }
   }
}

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Security;
using namespace System::Security::Permissions;

// Assumption : Dynamically created class might require reading of ;
// environment variable "TEMP", hence demands permission from caller.
Type^ CreateCallee( AppDomain^ appDomain )
{
   
   // Create a simple name for the assembly.
   AssemblyName^ myAssemblyName = gcnew AssemblyName;
   myAssemblyName->Name = "EmittedAssembly";
   
   // Create the called dynamic assembly.
   AssemblyBuilder^ myAssemblyBuilder = appDomain->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Run );
   ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "EmittedModule" );
   
   // Define a public class named "MyDynamicClass" in the assembly.
   TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "MyDynamicClass", TypeAttributes::Public );
   

   // Create a permission set and add a security permission
   // with the ControlEvidence flag.
   //
   PermissionSet^ myPermissionSet = gcnew PermissionSet(PermissionState::None);
   myPermissionSet->AddPermission(
      gcnew SecurityPermission(SecurityPermissionFlag::ControlEvidence));

   // Add the permission set to the MyDynamicClass type,
   // as a declarative security demand.
   //
   myTypeBuilder->AddDeclarativeSecurity(SecurityAction::Demand, myPermissionSet);

   
   // Define a private String field named "m_greeting" in the type.
   FieldBuilder^ myFieldBuilder = myTypeBuilder->DefineField( "m_greeting", String::typeid, FieldAttributes::Private );
   
   // Define constructor.
   array<Type^>^constructorArgs = {String::typeid};
   ConstructorBuilder^ myConstructorBuilder = myTypeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, constructorArgs );
   
   // Generate IL for the method.The constructor stores its argument in the private field.
   ILGenerator^ constructorIL = myConstructorBuilder->GetILGenerator();
   constructorIL->Emit( OpCodes::Ldarg_0 );
   constructorIL->Emit( OpCodes::Ldarg_1 );
   constructorIL->Emit( OpCodes::Stfld, myFieldBuilder );
   constructorIL->Emit( OpCodes::Ret );
   
   // Define property 'Greeting'.
   array<Type^>^propertyArgs = gcnew array<Type^>(0);
   PropertyBuilder^ myPropertyBuilder = myTypeBuilder->DefineProperty( "Greeting", PropertyAttributes::None, String::typeid, propertyArgs );
   
   // Create the get_Greeting method.
   MethodBuilder^ getGreetingMethod = myTypeBuilder->DefineMethod( "get_Greeting", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::HideBySig | MethodAttributes::SpecialName), String::typeid, nullptr );
   
   // Generate IL for get_Greeting method.
   ILGenerator^ methodIL = getGreetingMethod->GetILGenerator();
   methodIL->Emit( OpCodes::Ldarg_0 );
   methodIL->Emit( OpCodes::Ldfld, myFieldBuilder );
   methodIL->Emit( OpCodes::Ret );
   myPropertyBuilder->SetGetMethod( getGreetingMethod );
   Type^ myCustomClassType = myTypeBuilder->CreateType();
   return (myCustomClassType);
}

int main()
{
   Type^ customClassType = CreateCallee( Thread::GetDomain() );
   Console::WriteLine( "Trying to Create Instance with Default permission." );
   
   // Create an instance of the "MyDynamicClass" class.
   array<Object^>^temp0 = {"HelloWorld!!!"};
   Object^ myCustomObject = Activator::CreateInstance( customClassType, temp0 );
   
   // Get 'Greeting' property.
   Object^ objectGreeting = customClassType->InvokeMember( "Greeting", BindingFlags::GetProperty, nullptr, myCustomObject, nullptr );
   Console::WriteLine( "Property Value : {0}", objectGreeting );
   Console::WriteLine( "" );
   

   // Create a permission set that's the same as the set
   // demanded by the MyDynamicClass class.
   //
   PermissionSet^ myPermissionSet = gcnew PermissionSet( PermissionState::None );
   myPermissionSet->AddPermission(
      gcnew SecurityPermission(SecurityPermissionFlag::ControlEvidence));
   
   // Deny the permission set, and then try to create another
   // instance of the MyDynamicClass class.
   //  
   myPermissionSet->Deny();


   Console::WriteLine( "Trying to Create Instance after permission has been denied." );
   try
   {
      // Create an instance of the "MyDynamicClass" class.
      array<Object^>^temp1 = {"HelloWorld!!!"};
      Object^ myNewCustomObject = Activator::CreateInstance( customClassType, temp1 );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: Failed to create Instance" );
      Console::WriteLine( "'{0}'", e->Message );
   }
}

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

TypeBuilder.AddDeclarativeSecurity-Methode

Syntax

Parameter

Ausnahmen

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

Siehe auch

Referenz

Zusätzliche Ressourcen