MethodBuilder 類別

定義

命名空間:

System.Reflection.Emit

組件:

System.Reflection.Emit.dll

來源:

MethodBuilder.cs

定義及表示動態類別上的方法 (或建構函式)。

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

繼承

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

範例

下列範例會 MethodBuilder 使用 類別在動態類型內建立方法。

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

備註

如需此 API 的詳細資訊，請參閱 MethodBuilder 的補充 API 備註。

建構函式

MethodBuilder()

初始化 MethodBuilder 類別的新執行個體。

屬性

Attributes	擷取此方法的屬性。
CallingConvention	傳回方法的呼叫慣例。
ContainsGenericParameters	現在支援這種類型。
CustomAttributes	取得包含此成員之自訂屬性的集合。 (繼承來源 MemberInfo)
DeclaringType	傳回宣告這個方法的類型。
InitLocals	取得或設定布林值，指定在這個方法中的區域變數是否以零起始。 此屬性的預設值為 true。
InitLocalsCore	在衍生類別中覆寫時，取得或設定值，指出這個方法中的局部變數是否為零初始化。
IsAbstract	取得值，指出方法是否為抽象。 (繼承來源 MethodBase)
IsAssembly	取得值，指出 Assembly 是否描述此方法或建構函式 (Constructor) 的潛在可視性；亦即，最多只有相同組件 (Assembly) 中的其他型別可以看見該方法或建構函式，組件外部的衍生型別 (Derived Type) 則看不見它們。 (繼承來源 MethodBase)
IsCollectible	取得指出此 MemberInfo 物件是否為可回收 AssemblyLoadContext 中保存之組件一部分的值。 (繼承來源 MemberInfo)
IsConstructedGenericMethod	定義及表示動態類別上的方法 (或建構函式)。 (繼承來源 MethodBase)
IsConstructor	取得值，指出方法是否為建構函示。 (繼承來源 MethodBase)
IsFamily	取得值，指出 Family 是否描述此方法或建構函式的可視性；亦即，您只能在其類別和衍生類別內看見該方法或建構函式。 (繼承來源 MethodBase)
IsFamilyAndAssembly	取得值，指出 FamANDAssem 是否描述此方法或建構函式的可視性；亦即，只有當該方法或建構函式位於相同的組件時，衍生類別才能呼叫它們。 (繼承來源 MethodBase)
IsFamilyOrAssembly	取得值，指出 FamORAssem 是否描述此方法或建構函式的潛在可視性；亦即，無論該方法或建構函式位於何處，衍生類別以及相同組件中的類別都可以呼叫它們。 (繼承來源 MethodBase)
IsFinal	取得值，指出這個方法是否為 final。 (繼承來源 MethodBase)
IsGenericMethod	取得可指出此方法是否為泛型方法的值。
IsGenericMethodDefinition	取得值，指出目前的 MethodBuilder 物件是否代表泛型方法的定義。
IsHideBySig	取得值，指出是否只有簽章完全一樣的同類成員隱藏於衍生類別中。 (繼承來源 MethodBase)
IsPrivate	取得值，指出這個成員是否為私用的 (Private)。 (繼承來源 MethodBase)
IsPublic	取得值，指出這是否為公用的方法。 (繼承來源 MethodBase)
IsSecurityCritical	在所有情況下都擲回 NotSupportedException。
IsSecuritySafeCritical	在所有情況下都擲回 NotSupportedException。
IsSecurityTransparent	在所有情況下都擲回 NotSupportedException。
IsSpecialName	取得值，指出這個方法是否有特別的名稱。 (繼承來源 MethodBase)
IsStatic	取得值指出方法是否為 static。 (繼承來源 MethodBase)
IsVirtual	取得值指出方法是否為 virtual。 (繼承來源 MethodBase)
MemberType	取得 MemberTypes 值，表示這個成員為方法。 (繼承來源 MethodInfo)
MetadataToken	取得語彙基元，可識別中繼資料中的目前動態模組。
MethodHandle	擷取方法的內部控制代碼。 使用此控制代碼來存取基礎中繼資料控制代碼。
MethodImplementationFlags	取得 MethodImplAttributes 旗標，這些旗標會指定方法實作的屬性。 (繼承來源 MethodBase)
Module	取得所要定義之目前方法中的模組。
Name	擷取這個方法的名稱。
ReflectedType	取得用於反映中以取得方法的類別。
ReturnParameter	取得 ParameterInfo 物件，這個物件包含方法之傳回型別的相關資訊，例如傳回型別是否具有自訂修飾詞。
ReturnType	取得這個 MethodBuilder 所表示之方法的傳回型別。
ReturnTypeCustomAttributes	傳回方法之傳回型別的自訂屬性。

方法

CreateDelegate(Type)	從這個方法建立所指定類型的委派。 (繼承來源 MethodInfo)
CreateDelegate(Type, Object)	從這個方法以指定的目標建立所指定類型的委派。 (繼承來源 MethodInfo)
CreateDelegate<T>()	從這個方法建立類型 T 的委派。 (繼承來源 MethodInfo)
CreateDelegate<T>(Object)	從此方法建立具有指定目標之型別 T 的委派。 (繼承來源 MethodInfo)
DefineGenericParameters(String[])	設定目前方法的泛型型別參數數目、指定其名稱，並傳回可用來定義其條件約束的 GenericTypeParameterBuilder 物件陣列。
DefineGenericParametersCore(String[])	在衍生類別中覆寫時，設定目前方法的泛型型別參數數目、指定其名稱，並傳回可用來定義其條件約束的物件 GenericTypeParameterBuilder 數位。
DefineParameter(Int32, ParameterAttributes, String)	設定參數屬性和這個方法或這個方法傳回值的參數名稱。 傳回可用於套用自訂屬性的 ParameterBuilder。
DefineParameterCore(Int32, ParameterAttributes, String)	在衍生類別中覆寫時，定義這個方法的參數或傳回參數。
Equals(Object)	判斷指定的物件是否等於這個執行個體。
GetBaseDefinition()	傳回方法的基底實作。
GetCustomAttributes(Boolean)	傳回為這個方法定義的所有自訂屬性。
GetCustomAttributes(Type, Boolean)	傳回指定類型所識別的自訂屬性。
GetCustomAttributesData()	傳回 CustomAttributeData 物件的清單，表示已套用至目標成員之屬性的資料。 (繼承來源 MemberInfo)
GetGenericArguments()	如果它是泛型，則傳回 GenericTypeParameterBuilder 物件的陣列，代表此方法的型別參數。
GetGenericMethodDefinition()	傳回這個方法。
GetHashCode()	取得這個方法的雜湊碼。
GetILGenerator()	針對這個方法傳回具有 64 位元組之預設 Microsoft Intermediate Language (MSIL) 資料流大小的 ILGenerator。
GetILGenerator(Int32)	傳回具有指定之 Microsoft Intermediate Language (MSIL) 資料流大小的這個方法的 ILGenerator。
GetILGeneratorCore(Int32)	在衍生類別中覆寫時，取得 ILGenerator 可用來發出此方法之方法主體的 。
GetMethodBody()	在衍生類別中覆寫時，取得 MethodBody 物件，其提供對目前方法之 MSIL 資料流、區域變數和例外狀況的存取。 (繼承來源 MethodBase)
GetMethodImplementationFlags()	傳回方法的實作旗標。
GetParameters()	傳回這個方法的參數。
GetType()	探索方法的屬性 (Attribute) 並提供方法中繼資料 (Metadata) 的存取。 (繼承來源 MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	定義及表示動態類別上的方法 (或建構函式)。 (繼承來源 MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	動態叫用這個執行個體在指定物件上反映的方法，沿著指定參數，在指定繫結器的條件約束下傳遞。
Invoke(Object, Object[])	使用指定的參數叫用由目前執行個體代表的方法或建構函式。 (繼承來源 MethodInfo)
IsDefined(Type, Boolean)	檢查是否已定義指定的自訂屬性類型。
MakeGenericMethod(Type[])	傳回使用指定的泛型類型引數，從目前的泛型方法定義建構的泛型方法。
MemberwiseClone()	建立目前 Object 的淺層複製。 (繼承來源 Object)
SetCustomAttribute(ConstructorInfo, Byte[])	使用指定的自訂屬性 Blob 來設定自訂屬性。
SetCustomAttribute(CustomAttributeBuilder)	使用自訂屬性產生器來設定自訂屬性。
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	在衍生類別中覆寫時，在此元件上設定自定義屬性。
SetImplementationFlags(MethodImplAttributes)	設定此方法的實作旗標。
SetImplementationFlagsCore(MethodImplAttributes)	在衍生類別中覆寫時，設定此方法的實作旗標。
SetParameters(Type[])	設定方法的參數類型與數量。
SetReturnType(Type)	設定方法的傳回型別。
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	設定方法簽章，包含傳回類型、參數類型和傳回類型及參數類型之必要與選擇性自訂修飾詞。
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	在衍生類別中覆寫時，設定方法簽章，包括傳回型別、參數型別，以及傳回型別和參數型別的必要和選擇性自定義修飾詞。
ToString()	傳回此 MethodBuilder 執行個體做為字串。

擴充方法

GetCustomAttribute(MemberInfo, Type)	擷取指定型別的自訂屬性，此屬性套用至指定成員。
GetCustomAttribute(MemberInfo, Type, Boolean)	擷取只訂型別的自訂屬性，此屬性套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttribute<T>(MemberInfo)	擷取指定型別的自訂屬性，此屬性套用至指定成員。
GetCustomAttribute<T>(MemberInfo, Boolean)	擷取只訂型別的自訂屬性，此屬性套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes(MemberInfo)	擷取套用至指定成員的自訂屬性集合。
GetCustomAttributes(MemberInfo, Boolean)	擷取自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes(MemberInfo, Type)	擷取指定型別的自訂屬性集合，此集合套用至指定成員。
GetCustomAttributes(MemberInfo, Type, Boolean)	擷取指定型別的自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes<T>(MemberInfo)	擷取指定型別的自訂屬性集合，此集合套用至指定成員。
GetCustomAttributes<T>(MemberInfo, Boolean)	擷取指定型別的自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
IsDefined(MemberInfo, Type)	指出是否將所指定型別的自訂屬性套用至指定的成員。
IsDefined(MemberInfo, Type, Boolean)	指出指定之型別的自訂屬性是否會套用至指定的成員，以及選擇性地套用到其上階。
GetMetadataToken(MemberInfo)	取得指定成員的中繼資料語彙基元 (如果有)。
HasMetadataToken(MemberInfo)	傳回值，指出所指定成員是否有可用的中繼資料語彙基元。
GetBaseDefinition(MethodInfo)	定義及表示動態類別上的方法 (或建構函式)。
GetRuntimeBaseDefinition(MethodInfo)	擷取物件，表示直接或間接基底類別上的指定方法 (在這個類別上首次宣告這個方法)。