ConstructorBuilder.AddDeclarativeSecurity(SecurityAction, PermissionSet) Méthode

Définition

Ajoute la sécurité déclarative à ce constructeur.Adds declarative security to this constructor.

public:
 void AddDeclarativeSecurity(System::Security::Permissions::SecurityAction action, System::Security::PermissionSet ^ pset);
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);
member this.AddDeclarativeSecurity : System.Security.Permissions.SecurityAction * System.Security.PermissionSet -> unit
Public Sub AddDeclarativeSecurity (action As SecurityAction, pset As PermissionSet)

Paramètres

action
SecurityAction

Mesure de sécurité à prendre telle que Demand, Assert, etc.The security action to be taken, such as Demand, Assert, and so on.

pset
PermissionSet

Jeu d’autorisations auquel la mesure s’applique.The set of permissions the action applies to.

Exceptions

action n’est pas valide (RequestMinimum, RequestOptional et RequestRefuse ne sont pas valides).action is invalid (RequestMinimum, RequestOptional, and RequestRefuse are invalid).

Le type conteneur a déjà été créé à l’aide de CreateType().The containing type has been previously created using CreateType().

- ou --or- Le jeu d’autorisations pset contient une action qui a déjà été ajoutée par AddDeclarativeSecurity.The permission set pset contains an action that was added earlier by AddDeclarativeSecurity.

pset a la valeur null.pset is null.

Exemples

L’exemple de code suivant illustre l’utilisation de AddDeclarativeSecurity.The following code sample illustrates the use of AddDeclarativeSecurity.

MethodBuilder^ myMethodBuilder = nullptr;

AppDomain^ myCurrentDomain = AppDomain::CurrentDomain;
// Create assembly in current CurrentDomain
AssemblyName^ myAssemblyName = gcnew AssemblyName;
myAssemblyName->Name = "TempAssembly";
// Create a dynamic assembly
myAssemblyBuilder = myCurrentDomain->DefineDynamicAssembly(
   myAssemblyName, AssemblyBuilderAccess::RunAndSave );
// Create a dynamic module in the assembly.
myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "TempModule" );
FieldInfo^ myFieldInfo =
   myModuleBuilder->DefineUninitializedData( "myField", 2, FieldAttributes::Public );
// Create a type in the module
TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "TempClass", TypeAttributes::Public );
FieldBuilder^ myGreetingField = myTypeBuilder->DefineField( "Greeting",
   String::typeid, FieldAttributes::Public );
array<Type^>^myConstructorArgs = {String::typeid};
// Define a constructor of the dynamic class.
ConstructorBuilder^ myConstructor = myTypeBuilder->DefineConstructor(
   MethodAttributes::Public, CallingConventions::Standard, myConstructorArgs );
PermissionSet^ myPset = gcnew PermissionSet( PermissionState::Unrestricted );
// Add declarative security to the constructor.
Console::WriteLine( "Adding declarative security to the constructor....." );
Console::WriteLine( "The Security action to be taken is \"DENY\" and" +
   " Permission set is \"UNRESTRICTED\"." );
myConstructor->AddDeclarativeSecurity( SecurityAction::Deny, myPset );
MethodAttributes myMethodAttributes = myConstructor->Attributes;
Type^ myAttributeType = MethodAttributes::typeid;
int myAttribValue = (int)myMethodAttributes;
if (  !myAttributeType->IsEnum )
{
   Console::WriteLine( "This is not an Enum" );
}
array<FieldInfo^>^myFieldInfo1 = myAttributeType->GetFields( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Static) );
Console::WriteLine( "The Field info names of the Attributes for the constructor are:" );
for ( int i = 0; i < myFieldInfo1->Length; i++ )
{
   int myFieldValue =  *dynamic_cast<Int32^>(myFieldInfo1[ i ]->GetValue( nullptr ));
   if ( (myFieldValue & myAttribValue) == myFieldValue )
   {
      Console::WriteLine( "   {0}", myFieldInfo1[ i ]->Name );
   }
}

Type^ myType2 = myConstructor->DeclaringType;
Console::WriteLine( "The declaring type is : {0}", myType2 );
ParameterBuilder^ myParameterBuilder1 =
   myConstructor->DefineParameter( 1, ParameterAttributes::Out, "My Parameter Name1" );
Console::WriteLine( "The name of the parameter is : {0}",
   myParameterBuilder1->Name );
if ( myParameterBuilder1->IsIn )
      Console::WriteLine( "{0} is Input parameter.", myParameterBuilder1->Name );
else
      Console::WriteLine( "{0} is not Input Parameter.", myParameterBuilder1->Name );
ParameterBuilder^ myParameterBuilder2 =
   myConstructor->DefineParameter( 1, ParameterAttributes::In, "My Parameter Name2" );
Console::WriteLine( "The Parameter name is : {0}",
   myParameterBuilder2->Name );
if ( myParameterBuilder2->IsIn )
      Console::WriteLine( "{0} is Input parameter.", myParameterBuilder2->Name );
else
      Console::WriteLine( "{0} is not Input Parameter.", myParameterBuilder2->Name );
MethodBuilder myMethodBuilder=null;

AppDomain myCurrentDomain = AppDomain.CurrentDomain;
// Create assembly in current CurrentDomain
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "TempAssembly";
// Create a dynamic assembly
myAssemblyBuilder = myCurrentDomain.DefineDynamicAssembly
   (myAssemblyName, AssemblyBuilderAccess.RunAndSave);
// Create a dynamic module in the assembly.
myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule");
FieldInfo myFieldInfo =
   myModuleBuilder.DefineUninitializedData("myField",2,FieldAttributes.Public);
// Create a type in the module
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("TempClass",TypeAttributes.Public);
FieldBuilder myGreetingField = myTypeBuilder.DefineField("Greeting",
   typeof(String), FieldAttributes.Public);
Type[] myConstructorArgs = { typeof(String) };
// Define a constructor of the dynamic class.
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
   MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);
PermissionSet myPset = new PermissionSet(PermissionState.Unrestricted);
// Add declarative security to the constructor.
Console.WriteLine("Adding declarative security to the constructor.....");
Console.WriteLine("The Security action to be taken is \"DENY\" and" +
   " Permission set is \"UNRESTRICTED\".");
myConstructor.AddDeclarativeSecurity(SecurityAction.Deny,myPset);
MethodAttributes myMethodAttributes = myConstructor.Attributes;
Type myAttributeType = typeof(MethodAttributes);
int myAttribValue = (int) myMethodAttributes;
if(! myAttributeType.IsEnum)
{
   Console.WriteLine("This is not an Enum");
}
FieldInfo[] myFieldInfo1 = myAttributeType.GetFields(BindingFlags.Public | BindingFlags.Static);
Console.WriteLine("The Field info names of the Attributes for the constructor are:");
for (int i = 0; i < myFieldInfo1.Length; i++)
{
   int myFieldValue = (Int32)myFieldInfo1[i].GetValue(null);
   if ((myFieldValue & myAttribValue) == myFieldValue)
   {
      Console.WriteLine("   " + myFieldInfo1[i].Name);
   }
}

Type myType2 = myConstructor.DeclaringType;
Console.WriteLine("The declaring type is : "+myType2.ToString());
ParameterBuilder myParameterBuilder1 =
   myConstructor.DefineParameter(1,  ParameterAttributes.Out, "My Parameter Name1");
Console.WriteLine("The name of the parameter is : " +
   myParameterBuilder1.Name);
if(myParameterBuilder1.IsIn)
   Console.WriteLine(myParameterBuilder1.Name +" is Input parameter.");
else
   Console.WriteLine(myParameterBuilder1.Name +" is not Input Parameter.");
ParameterBuilder myParameterBuilder2 =
   myConstructor.DefineParameter(1, ParameterAttributes.In, "My Parameter Name2");
Console.WriteLine("The Parameter name is : " +
   myParameterBuilder2.Name);
if(myParameterBuilder2.IsIn)
   Console.WriteLine(myParameterBuilder2.Name +" is Input parameter.");
else
   Console.WriteLine(myParameterBuilder2.Name + " is not Input Parameter.");
Dim myMethodBuilder As MethodBuilder = Nothing

Dim myCurrentDomain As AppDomain = AppDomain.CurrentDomain
' Create assembly in current CurrentDomain
Dim myAssemblyName As New AssemblyName()
myAssemblyName.Name = "TempAssembly"
' Create a dynamic assembly
myAssemblyBuilder = _
      myCurrentDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.RunAndSave)
' Create a dynamic module in the assembly.
myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule")
Dim myFieldInfo As FieldInfo = _
    myModuleBuilder.DefineUninitializedData("myField", 2, FieldAttributes.Public)
' Create a type in the module
Dim myTypeBuilder As TypeBuilder = _
    myModuleBuilder.DefineType("TempClass", TypeAttributes.Public)
Dim myGreetingField As FieldBuilder = _
   myTypeBuilder.DefineField("Greeting", GetType(String), FieldAttributes.Public)
Dim myConstructorArgs As Type() = {GetType(String)}
' Define a constructor of the dynamic class.
Dim myConstructor As ConstructorBuilder = _
    myTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, _
                                    myConstructorArgs)
Dim myPset As New PermissionSet(PermissionState.Unrestricted)
' Add declarative security to the constructor.
Console.WriteLine("Adding declarative security to the constructor.....")
Console.WriteLine("The Security action to be taken is ""DENY"" and" + _
                  " Permission set is ""UNRESTRICTED"".")
myConstructor.AddDeclarativeSecurity(SecurityAction.Deny, myPset)
Dim myMethodAttributes As MethodAttributes = myConstructor.Attributes
Dim myAttributeType As Type = GetType(MethodAttributes)
Dim myAttribValue As Integer = CInt(myMethodAttributes)
If Not myAttributeType.IsEnum Then
   Console.WriteLine("This is not an Enum")
End If
Dim myFieldInfo1 As FieldInfo() = myAttributeType.GetFields(BindingFlags.Public Or _
                                                             BindingFlags.Static)
Console.WriteLine("The Field info names of the Attributes for the constructor are:")
Dim i As Integer
For i = 0 To myFieldInfo1.Length - 1
   Dim myFieldValue As Integer = CType(myFieldInfo1(i).GetValue(Nothing), Int32)
   If(myFieldValue And myAttribValue) = myFieldValue Then
      Console.WriteLine("   " + myFieldInfo1(i).Name)
   End If
Next i

Dim myType2 As Type = myConstructor.DeclaringType
Console.WriteLine("The declaring type is : " + myType2.ToString())
Dim myParameterBuilder1 As ParameterBuilder = _
    myConstructor.DefineParameter(1, ParameterAttributes.Out, "My Parameter Name1")
Console.WriteLine("The name of the parameter is : " + myParameterBuilder1.Name)
If myParameterBuilder1.IsIn Then
   Console.WriteLine(myParameterBuilder1.Name + " is Input parameter.")
Else
   Console.WriteLine(myParameterBuilder1.Name + " is not Input Parameter.")
End If
Dim myParameterBuilder2 As ParameterBuilder = _
    myConstructor.DefineParameter(1, ParameterAttributes.In, "My Parameter Name2")
Console.WriteLine("The Parameter name is : " + myParameterBuilder2.Name)
If myParameterBuilder2.IsIn Then
   Console.WriteLine(myParameterBuilder2.Name + " is Input parameter.")
Else
   Console.WriteLine(myParameterBuilder2.Name + " is not Input Parameter.")
End If

Remarques

AddDeclarativeSecurity peut être appelée plusieurs fois, chaque appel spécifiant une action de sécurité (par exemple, Demand, Assertet Deny) et un jeu d’autorisations auquel l’action s’applique.AddDeclarativeSecurity can be called several times, with each call specifying a security action (such as Demand, Assert, and Deny) and a set of permissions that the action applies to.

Notes

Dans les versions 1,0, 1,1 et 2,0 du .NET Framework, les attributs de sécurité déclaratifs appliqués à un constructeur à l’aide de cette méthode sont stockés dans l’ancien format de métadonnées XML.In the .NET Framework versions 1.0, 1.1, and 2.0, the declarative security attributes applied to a constructor by using this method are stored in the old XML metadata format. Consultez émission d’attributs de sécurité déclaratifs.See Emitting Declarative Security Attributes.

S’applique à