MethodBuilder Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.dll

Sumber:

MethodBuilder.cs

Mendefinisikan dan mewakili metode (atau konstruktor) pada kelas dinamis.

public ref class MethodBuilder abstract : System::Reflection::MethodInfo

public abstract class MethodBuilder : System.Reflection.MethodInfo

type MethodBuilder = class
    inherit MethodInfo

Public MustInherit Class MethodBuilder
Inherits MethodInfo

Warisan

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Contoh

Contoh berikut menggunakan MethodBuilder kelas untuk membuat metode dalam jenis dinamis.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void AddMethodDynamically( TypeBuilder^ myTypeBld, 
                           String^ mthdName, 
                           array<Type^>^ mthdParams, 
                           Type^ returnType, 
                           String^ mthdAction )
{
   MethodBuilder^ myMthdBld = myTypeBld->DefineMethod( mthdName, static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), returnType, mthdParams );
   ILGenerator^ ILOut = myMthdBld->GetILGenerator();
   int numParams = mthdParams->Length;
   for ( Byte x = 0; x < numParams; x++ )
   {
      ILOut->Emit( OpCodes::Ldarg_S, x );

   }
   if ( numParams > 1 )
   {
      for ( int y = 0; y < (numParams - 1); y++ )
      {
         if ( mthdAction->Equals( "A" ) )
                  ILOut->Emit( OpCodes::Add );
         else
         if ( mthdAction->Equals( "M" ) )
                  ILOut->Emit( OpCodes::Mul );
         else
                  ILOut->Emit( OpCodes::Add );

      }
   }

   ILOut->Emit( OpCodes::Ret );
};

void main()
{
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ asmName = gcnew AssemblyName;
   asmName->Name = "MyDynamicAsm";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( asmName, 
                                                                    AssemblyBuilderAccess::RunAndSave );
   ModuleBuilder^ myModule = myAsmBuilder->DefineDynamicModule( "MyDynamicAsm", 
                                                                "MyDynamicAsm.dll" );
   TypeBuilder^ myTypeBld = myModule->DefineType( "MyDynamicType", 
                                                  TypeAttributes::Public );
   
   // Get info from the user to build the method dynamically.
   Console::WriteLine( "Let's build a simple method dynamically!" );
   Console::WriteLine( "Please enter a few numbers, separated by spaces." );
   String^ inputNums = Console::ReadLine();
   Console::Write( "Do you want to [A]dd (default) or [M]ultiply these numbers? " );
   String^ myMthdAction = Console::ReadLine()->ToUpper();
   Console::Write( "Lastly, what do you want to name your new dynamic method? " );
   String^ myMthdName = Console::ReadLine();
   
   // Process inputNums into an array and create a corresponding Type array
   int index = 0;
   array<String^>^inputNumsList = inputNums->Split();
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   for each (String^ inputNum in inputNumsList)
   {
      inputValsList[ index ] = Convert::ToInt32( inputNum );
      myMthdParams[ index ] = int::typeid;
      index++;
   }

   
   // Now, call the method building method with the parameters, passing the
   // TypeBuilder by reference.
   AddMethodDynamically( myTypeBld, 
                         myMthdName, 
                         myMthdParams, 
                         int::typeid, 
                         myMthdAction );
   Type^ myType = myTypeBld->CreateType();

   Console::WriteLine( "---" );
   Console::WriteLine( "The result of {0} the inputted values is: {1}", 
                       ((myMthdAction->Equals( "M" )) ? "multiplying" : "adding"), 
                       myType->InvokeMember( myMthdName, 
                                             BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
                       nullptr, 
                       nullptr, 
                       inputValsList ) );
   Console::WriteLine( "---" );
   
   // Let's take a look at the method we created.
   // If you are interested in seeing the MSIL generated dynamically for the method
   // your program generated, change to the directory where you ran the compiled
   // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
   // of manifest contents appears, click on "MyDynamicType" and then on the name of
   // of the method you provided during execution.

   myAsmBuilder->Save( "MyDynamicAsm.dll" );

   MethodInfo^ myMthdInfo = myType->GetMethod( myMthdName );
   Console::WriteLine( "Your Dynamic Method: {0};", myMthdInfo );
}

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

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

Keterangan

Untuk informasi selengkapnya tentang API ini, lihat Keterangan API Tambahan untuk MethodBuilder.

Konstruktor

MethodBuilder()

Menginisialisasi instans baru kelas MethodBuilder.

Properti

Attributes	Mengambil atribut untuk metode ini.
CallingConvention	Mengembalikan konvensi panggilan metode .
ContainsGenericParameters	Tidak didukung untuk tipe ini.
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaringType	Mengembalikan tipe yang menyatakan metode ini.
InitLocals	Mendapatkan atau menetapkan nilai Boolean yang menentukan apakah variabel lokal dalam metode ini tidak diinisialisasi. Nilai default properti ini adalah true.
InitLocalsCore	Ketika ditimpa di kelas turunan, mendapatkan atau menetapkan nilai yang menunjukkan apakah variabel lokal dalam metode ini diinisialisasi nol.
IsAbstract	Mendapatkan nilai yang menunjukkan apakah metode tersebut abstrak. (Diperoleh dari MethodBase)
IsAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial dari metode atau konstruktor ini dijelaskan oleh ; yaitu, metode atau konstruktor terlihat paling banyak ke jenis lain dalam perakitan yang sama, dan tidak terlihat oleh Assemblyjenis turunan di luar perakitan. (Diperoleh dari MethodBase)
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo adalah bagian dari perakitan yang dipegang dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsConstructedGenericMethod	Mendefinisikan dan mewakili metode (atau konstruktor) pada kelas dinamis. (Diperoleh dari MethodBase)
IsConstructor	Mendapatkan nilai yang menunjukkan apakah metode tersebut adalah konstruktor. (Diperoleh dari MethodBase)
IsFamily	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh Family; yaitu, metode atau konstruktor hanya terlihat dalam kelas dan kelas turunannya. (Diperoleh dari MethodBase)
IsFamilyAndAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh FamANDAssem; yaitu, metode atau konstruktor dapat dipanggil oleh kelas turunan, tetapi hanya jika mereka berada dalam perakitan yang sama. (Diperoleh dari MethodBase)
IsFamilyOrAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial dari metode atau konstruktor ini dijelaskan oleh FamORAssem; yaitu, metode atau konstruktor dapat dipanggil oleh kelas turunan di mana pun mereka berada, dan berdasarkan kelas dalam perakitan yang sama. (Diperoleh dari MethodBase)
IsFinal	Mendapatkan nilai yang menunjukkan apakah metode ini adalah final. (Diperoleh dari MethodBase)
IsGenericMethod	Mendapatkan nilai yang menunjukkan apakah metode tersebut adalah metode generik.
IsGenericMethodDefinition	Mendapatkan nilai yang menunjukkan apakah objek saat ini MethodBuilder mewakili definisi metode generik.
IsHideBySig	Mendapatkan nilai yang menunjukkan apakah hanya anggota dari jenis yang sama dengan tanda tangan yang sama persis yang disembunyikan di kelas turunan. (Diperoleh dari MethodBase)
IsPrivate	Mendapatkan nilai yang menunjukkan apakah anggota ini bersifat privat. (Diperoleh dari MethodBase)
IsPublic	Mendapatkan nilai yang menunjukkan apakah ini adalah metode publik. (Diperoleh dari MethodBase)
IsSecurityCritical	NotSupportedException Melemparkan dalam semua kasus.
IsSecuritySafeCritical	NotSupportedException Melemparkan dalam semua kasus.
IsSecurityTransparent	NotSupportedException Melemparkan dalam semua kasus.
IsSpecialName	Mendapatkan nilai yang menunjukkan apakah metode ini memiliki nama khusus. (Diperoleh dari MethodBase)
IsStatic	Mendapatkan nilai yang menunjukkan apakah metodenya adalah static. (Diperoleh dari MethodBase)
IsVirtual	Mendapatkan nilai yang menunjukkan apakah metodenya adalah virtual. (Diperoleh dari MethodBase)
MemberType	Mendapatkan nilai yang MemberTypes menunjukkan bahwa anggota ini adalah metode . (Diperoleh dari MethodInfo)
MetadataToken	Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.
MethodHandle	Mengambil handel internal untuk metode . Gunakan handel ini untuk mengakses handel metadata yang mendasar.
MethodImplementationFlags	MethodImplAttributes Mendapatkan bendera yang menentukan atribut implementasi metode. (Diperoleh dari MethodBase)
Module	Mendapatkan modul di mana metode saat ini sedang didefinisikan.
Name	Mengambil nama metode ini.
ReflectedType	Mengambil kelas yang digunakan dalam refleksi untuk mendapatkan objek ini.
ReturnParameter	ParameterInfo Mendapatkan objek yang berisi informasi tentang jenis pengembalian metode, seperti apakah jenis pengembalian memiliki pengubah kustom.
ReturnType	Mendapatkan jenis pengembalian metode yang diwakili oleh ini MethodBuilder.
ReturnTypeCustomAttributes	Mengembalikan atribut kustom dari jenis pengembalian metode.

Metode

CreateDelegate(Type)	Membuat delegasi jenis yang ditentukan dari metode ini. (Diperoleh dari MethodInfo)
CreateDelegate(Type, Object)	Membuat delegasi jenis yang ditentukan dengan target yang ditentukan dari metode ini. (Diperoleh dari MethodInfo)
CreateDelegate<T>()	Membuat delegasi jenis T dari metode ini. (Diperoleh dari MethodInfo)
CreateDelegate<T>(Object)	Membuat delegasi jenis T dengan target yang ditentukan dari metode ini. (Diperoleh dari MethodInfo)
DefineGenericParameters(String[])	Mengatur jumlah parameter jenis generik untuk metode saat ini, menentukan namanya, dan mengembalikan array GenericTypeParameterBuilder objek yang dapat digunakan untuk menentukan batasannya.
DefineGenericParametersCore(String[])	Saat ditimpa dalam kelas turunan, mengatur jumlah parameter jenis generik untuk metode saat ini, menentukan namanya, dan mengembalikan array GenericTypeParameterBuilder objek yang dapat digunakan untuk menentukan batasannya.
DefineParameter(Int32, ParameterAttributes, String)	Mengatur atribut parameter dan nama parameter metode ini, atau dari nilai pengembalian metode ini. Mengembalikan ParameterBuilder yang dapat digunakan untuk menerapkan atribut kustom.
DefineParameterCore(Int32, ParameterAttributes, String)	Ketika ditimpa di kelas turunan, menentukan parameter atau parameter pengembalian untuk metode ini.
Equals(Object)	Menentukan apakah objek yang diberikan sama dengan instans ini.
GetBaseDefinition()	Mengembalikan implementasi dasar untuk metode .
GetCustomAttributes(Boolean)	Mengembalikan semua atribut kustom yang ditentukan untuk metode ini.
GetCustomAttributes(Type, Boolean)	Mengembalikan atribut kustom yang diidentifikasi oleh jenis yang diberikan.
GetCustomAttributesData()	Mengembalikan daftar CustomAttributeData objek yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetGenericArguments()	Mengembalikan array GenericTypeParameterBuilder objek yang mewakili parameter jenis metode, jika generik.
GetGenericMethodDefinition()	Mengembalikan metode ini.
GetHashCode()	Mendapatkan kode hash untuk metode ini.
GetILGenerator()	ILGenerator Mengembalikan untuk metode ini dengan ukuran aliran bahasa perantara Microsoft (MSIL) default sebesar 64 byte.
GetILGenerator(Int32)	Mengembalikan ILGenerator untuk metode ini dengan ukuran aliran bahasa perantara Microsoft (MSIL) yang ditentukan.
GetILGeneratorCore(Int32)	Ketika ditimpa di kelas turunan ILGenerator , mendapatkan yang dapat digunakan untuk memancarkan isi metode untuk metode ini.
GetMethodBody()	Ketika ditimpa di kelas turunan, mendapatkan MethodBody objek yang menyediakan akses ke aliran MSIL, variabel lokal, dan pengecualian untuk metode saat ini. (Diperoleh dari MethodBase)
GetMethodImplementationFlags()	Mengembalikan bendera implementasi untuk metode .
GetParameters()	Mengembalikan parameter metode ini.
GetType()	Menemukan atribut metode dan menyediakan akses ke metadata metode. (Diperoleh dari MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Mendefinisikan dan mewakili metode (atau konstruktor) pada kelas dinamis. (Diperoleh dari MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Secara dinamis memanggil metode yang tercermin oleh instans ini pada objek yang diberikan, melewati parameter yang ditentukan, dan di bawah batasan pengikat yang diberikan.
Invoke(Object, Object[])	Memanggil metode atau konstruktor yang diwakili oleh instans saat ini, menggunakan parameter yang ditentukan. (Diperoleh dari MethodInfo)
IsDefined(Type, Boolean)	Memeriksa apakah jenis atribut kustom yang ditentukan ditentukan.
MakeGenericMethod(Type[])	Mengembalikan metode generik yang dibangun dari definisi metode generik saat ini menggunakan argumen jenis generik yang ditentukan.
MemberwiseClone()	Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Mengatur atribut kustom menggunakan blob atribut kustom tertentu.
SetCustomAttribute(CustomAttributeBuilder)	Mengatur atribut kustom menggunakan penyusun atribut kustom.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Saat ditimpa di kelas turunan, mengatur atribut kustom pada assembly ini.
SetImplementationFlags(MethodImplAttributes)	Mengatur bendera implementasi untuk metode ini.
SetImplementationFlagsCore(MethodImplAttributes)	Ketika ditimpa di kelas turunan, mengatur bendera implementasi untuk metode ini.
SetParameters(Type[])	Mengatur jumlah dan jenis parameter untuk metode .
SetReturnType(Type)	Mengatur jenis pengembalian metode.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Mengatur tanda tangan metode, termasuk jenis pengembalian, jenis parameter, dan pengubah kustom yang diperlukan dan opsional dari jenis pengembalian dan jenis parameter.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, mengatur tanda tangan metode, termasuk jenis pengembalian, jenis parameter, dan pengubah kustom yang diperlukan dan opsional dari jenis pengembalian dan jenis parameter.
ToString()	Mengembalikan instans ini MethodBuilder sebagai string.

Metode Ekstensi

GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.
GetBaseDefinition(MethodInfo)	Mendefinisikan dan mewakili metode (atau konstruktor) pada kelas dinamis.
GetRuntimeBaseDefinition(MethodInfo)	Mengambil objek yang mewakili metode yang ditentukan pada kelas dasar langsung atau tidak langsung tempat metode pertama kali dideklarasikan.