Partilhar via


ConstructorBuilder.AddDeclarativeSecurity Método

Definição

Adiciona a segurança declarativa a esse construtor.

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)

Parâmetros

action
SecurityAction

A ação de segurança a ser executada, como Demand, Assert e assim por diante.

pset
PermissionSet

O conjunto de permissões ao qual a ação se aplica.

Exceções

action é inválido (RequestMinimum, RequestOptional e RequestRefuse são inválidos).

O tipo recipiente foi criado anteriormente usando CreateType().

- ou -

O conjunto de permissões pset contém uma ação que foi adicionada anteriormente por AddDeclarativeSecurity.

pset é null.

Exemplos

O exemplo de código a seguir ilustra o uso de 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

Comentários

AddDeclarativeSecurity pode ser chamado várias vezes, com cada chamada especificando uma ação de segurança (como Demand, Asserte Deny) e um conjunto de permissões às quais a ação se aplica.

Observação

No .NET Framework versões 1.0, 1.1 e 2.0, os atributos de segurança declarativos aplicados a um construtor usando esse método são armazenados no formato de metadados XML antigo. Consulte Emitindo atributos de segurança declarativos.

Aplica-se a