ConstructorBuilder.DeclaringType Propriété

Définition

Obtient une référence à l’objet Type pour le type qui déclare ce membre.Gets a reference to the Type object for the type that declares this member.

public:
 virtual property Type ^ DeclaringType { Type ^ get(); };
public override Type DeclaringType { get; }
member this.DeclaringType : Type
Public Overrides ReadOnly Property DeclaringType As Type

Valeur de propriété

Type qui déclare ce membre.The type that declares this member.

Remarques

Un membre d’une classe (ou d’une interface) est déclaré ou hérité d’une classe de base (ou interface).A member of a class (or interface) is either declared or inherited from a base class (or interface).

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

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 );
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());
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())

S’applique à