MethodBuilder.DeclaringType Propriedade

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Retorna o tipo que declara a este método.

public:
 virtual property Type ^ DeclaringType { Type ^ get(); };

public override Type? DeclaringType { get; }

member this.DeclaringType : Type

Public Overrides ReadOnly Property DeclaringType As Type

Valor da propriedade

Type

Somente leitura. O tipo que declara esse método.

Exemplos

O código a seguir ilustra o uso da Type propriedade .

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
int main()
{
   try
   {
      // Get the current AppDomain.
      AppDomain^ myAppDomain = AppDomain::CurrentDomain;
      AssemblyName^ myAssemblyName = gcnew AssemblyName;
      myAssemblyName->Name = "MyDynamicAssembly";

      // Create the dynamic assembly and set its access mode to 'Save'.
      AssemblyBuilder^ myAssemblyBuilder = myAppDomain->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Save );

      // Create a dynamic module 'myModuleBuilder'.
      ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "MyDynamicModule", true );

      // Define a public class 'MyDynamicClass'.
      TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "MyDynamicClass", TypeAttributes::Public );

      // Define a public string field named 'myField'.
      FieldBuilder^ myField = myTypeBuilder->DefineField( "MyDynamicField", String::typeid, FieldAttributes::Public );

      // Define the dynamic method 'MyDynamicMethod'.
      array<Type^>^temp0 = gcnew array<Type^>(0);
      MethodBuilder^ myMethodBuilder = myTypeBuilder->DefineMethod( "MyDynamicMethod", MethodAttributes::Private, int::typeid, temp0 );

      // Generate the IL for 'myMethodBuilder'.
      ILGenerator^ myMethodIL = myMethodBuilder->GetILGenerator();

      // Emit the necessary opcodes.
      myMethodIL->Emit( OpCodes::Ldarg_0 );
      myMethodIL->Emit( OpCodes::Ldfld, myField );
      myMethodIL->Emit( OpCodes::Ret );

      // Create 'myTypeBuilder' class.
      Type^ myType1 = myTypeBuilder->CreateType();

      // Get the method information of 'myTypeBuilder'.
      array<MethodInfo^>^myInfo = myType1->GetMethods( static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance) );

      // Print non-public methods present of 'myType1'.
      Console::WriteLine( "\nThe Non-Public methods present in 'myType1' are:\n" );
      for ( int i = 0; i < myInfo->Length; i++ )
      {
         Console::WriteLine( myInfo[ i ]->Name );
      }
      Console::WriteLine( "\nThe Attribute of 'MyDynamicMethod' is :{0}", myMethodBuilder->Attributes );
      Console::WriteLine( "\nThe Signature of 'MyDynamicMethod' is : \n{0}", myMethodBuilder->Signature );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception :{0}", e->Message );
   }
}

using System;
using System.Reflection;
using System.Reflection.Emit;

public class MethodBuilderClass
{
   public static void Main()
   {
      try
      {
         // Get the current AppDomain.
         AppDomain myAppDomain = AppDomain.CurrentDomain;
         AssemblyName myAssemblyName = new AssemblyName();
         myAssemblyName.Name = "MyDynamicAssembly";

         // Create the dynamic assembly and set its access mode to 'Save'.
         AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(
                        myAssemblyName, AssemblyBuilderAccess.Save);
         // Create a dynamic module 'myModuleBuilder'.
         ModuleBuilder myModuleBuilder =
              myAssemblyBuilder.DefineDynamicModule("MyDynamicModule", true);
         // Define a public class 'MyDynamicClass'.
         TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyDynamicClass",
                                                 TypeAttributes.Public);
         // Define a public string field named 'myField'.
         FieldBuilder myField = myTypeBuilder.DefineField("MyDynamicField",
                        typeof(String), FieldAttributes.Public);

         // Define the dynamic method 'MyDynamicMethod'.
         MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("MyDynamicMethod",
                              MethodAttributes.Private, typeof(int), new Type[] {});
         // Generate the IL for 'myMethodBuilder'.
         ILGenerator myMethodIL = myMethodBuilder.GetILGenerator();
         // Emit the necessary opcodes.
         myMethodIL.Emit(OpCodes.Ldarg_0);
         myMethodIL.Emit(OpCodes.Ldfld, myField);
         myMethodIL.Emit(OpCodes.Ret);

         // Create 'myTypeBuilder' class.
         Type myType1 = myTypeBuilder.CreateType();

         // Get the method information of 'myTypeBuilder'.
         MethodInfo[] myInfo = myType1.GetMethods(BindingFlags.NonPublic |
                                                BindingFlags.Instance);
         // Print non-public methods present of 'myType1'.
         Console.WriteLine("\nThe Non-Public methods present in 'myType1' are:\n");
         for(int i = 0; i < myInfo.Length; i++)
         {
            Console.WriteLine(myInfo[i].Name);
         }
         // Print the 'Attribute', 'Signature' of 'myMethodBuilder'.
         Console.WriteLine("\nThe Attribute of 'MyDynamicMethod' is :{0}" ,
                                    myMethodBuilder.Attributes);
         Console.WriteLine("\nThe Signature of 'MyDynamicMethod' is : \n"
                                    + myMethodBuilder.Signature);
      }
      catch(Exception e)
      {
         Console.WriteLine("Exception :{0}", e.Message);
      }
   }
}

Imports System.Reflection
Imports System.Reflection.Emit

Public Class MethodBuilderClass

   Public Shared Sub Main()
      Try
         ' Get the current AppDomain.
         Dim myAppDomain As AppDomain = AppDomain.CurrentDomain
         Dim myAssemblyName As New AssemblyName()
         myAssemblyName.Name = "MyDynamicAssembly"

         ' Create the dynamic assembly and set its access mode to 'Save'.
         Dim myAssemblyBuilder As AssemblyBuilder = myAppDomain.DefineDynamicAssembly _
                                                      (myAssemblyName, AssemblyBuilderAccess.Save)
         ' Create a dynamic module 'myModuleBuilder'.
         Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.DefineDynamicModule _
                                                                     ("MyDynamicModule", True)
         ' Define a public class 'MyDynamicClass'.
         Dim myTypeBuilder As TypeBuilder = myModuleBuilder.DefineType _
                                                      ("MyDynamicClass", TypeAttributes.Public)
         ' Define a public string field named 'myField'.
         Dim myField As FieldBuilder = myTypeBuilder.DefineField("MyDynamicField", _
                                                   GetType(String), FieldAttributes.Public)
         ' Define the dynamic method 'MyDynamicMethod'.
         Dim myMethodBuilder As MethodBuilder = myTypeBuilder.DefineMethod("MyDynamicMethod", _
                                 MethodAttributes.Private, GetType(Integer), New Type() {})
         ' Generate the IL for 'myMethodBuilder'.
         Dim myMethodIL As ILGenerator = myMethodBuilder.GetILGenerator()
         ' Emit the necessary opcodes.
         myMethodIL.Emit(OpCodes.Ldarg_0)
         myMethodIL.Emit(OpCodes.Ldfld, myField)
         myMethodIL.Emit(OpCodes.Ret)

         ' Create 'myTypeBuilder' class.
         Dim myType1 As Type = myTypeBuilder.CreateType()

         ' Get the method information of 'myTypeBuilder'.
         Dim myInfo As MethodInfo() = myType1.GetMethods(BindingFlags.NonPublic Or _
                                                         BindingFlags.Instance)
         ' Print non-public methods present of 'myType1'.
         Console.WriteLine(ControlChars.Newline + "The Non-Public methods present in 'myType1' are:" + _
                                                                           ControlChars.NewLine)
         Dim i As Integer
         For i = 0 To myInfo.Length - 1
            Console.WriteLine(myInfo(i).Name)
         Next i
         ' Print the 'Attribute', 'Signature' of 'myMethodBuilder'.
         Console.WriteLine(ControlChars.Newline + "The Attribute of 'MyDynamicMethod' is :{0}", _
                                                                        myMethodBuilder.Attributes)
         Console.WriteLine(ControlChars.Newline + "The Signature of 'MyDynamicMethod' is : " + _
                                                ControlChars.Newline + myMethodBuilder.Signature)
      Catch e As Exception
         Console.WriteLine("Exception :{0}", e.Message)
      End Try
   End Sub
End Class