MethodBuilder Klasse

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Quelle:

MethodBuilder.cs

Definiert eine Methode (oder einen Konstruktor) für eine dynamischen Klasse und stellt diese(n) dar.

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

Vererbung

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Beispiele

Im folgenden Beispiel wird die MethodBuilder -Klasse verwendet, um eine Methode innerhalb eines dynamischen Typs zu erstellen.

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

Hinweise

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für MethodBuilder.

Konstruktoren

MethodBuilder()

Initialisiert eine neue Instanz der MethodBuilder-Klasse.

Eigenschaften

Attributes	Ruft die Attribute für diese Methode ab.
CallingConvention	Gibt die Aufrufkonvention der Methode zurück.
ContainsGenericParameters	Für diesen Typ nicht unterstützt.
CustomAttributes	Ruft eine Sammlung ab, die die benutzerdefinierten Attribute dieses Members enthält. (Geerbt von MemberInfo)
DeclaringType	Gibt den Typ zurück, der diese Methode deklariert.
InitLocals	Ruft einen booleschen Wert ab, der angibt, ob die lokalen Variablen in dieser Methode mit 0 (null) initialisiert werden, oder legt diesen Wert fest. Der Standardwert dieser Eigenschaft ist true.
InitLocalsCore	Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob die lokalen Variablen in dieser Methode null initialisiert sind, oder legt diesen fest.
IsAbstract	Ruft einen Wert ab, der angibt, ob es sich um eine abstrakte Methode handelt. (Geerbt von MethodBase)
IsAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode bzw. dieses Konstruktors von Assembly beschrieben wird, d. h., die Methode oder der Konstruktor ist höchstens für andere Typen in derselben Assembly sichtbar, nicht jedoch für abgeleitete Typen außerhalb der Assembly. (Geerbt von MethodBase)
IsCollectible	Ruft einen Wert ab, der angibt, ob dieses AssemblyLoadContext-Objekt Teil einer Assembly ist, die sich in einem entladbaren MemberInfo befindet. (Geerbt von MemberInfo)
IsConstructedGenericMethod	Definiert eine Methode (oder einen Konstruktor) für eine dynamischen Klasse und stellt diese(n) dar. (Geerbt von MethodBase)
IsConstructor	Ruft einen Wert ab, der angibt, ob die Methode ein Konstruktor ist. (Geerbt von MethodBase)
IsFamily	Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode bzw. dieses Konstruktors durch Family beschrieben wird, d. h., die Methode oder der Konstruktor ist nur sichtbar innerhalb ihrer bzw. seiner Klassen und in den abgeleiteten Klassen. (Geerbt von MethodBase)
IsFamilyAndAssembly	Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode oder dieses Konstruktors durch FamANDAssem beschrieben wird, d. h., die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, jedoch nur, wenn sie bzw. er sich in derselben Assembly befindet. (Geerbt von MethodBase)
IsFamilyOrAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder dieses Konstruktors durch FamORAssem beschrieben wird, d. h., die Methode bzw. der Konstruktor kann von Klassen in derselben Assembly und von abgeleiteten Klassen abgerufen werden, wobei es keine Rolle spielt, an welcher Position sich diese befinden. (Geerbt von MethodBase)
IsFinal	Ruft einen Wert ab, der angibt, ob diese Methode final ist. (Geerbt von MethodBase)
IsGenericMethod	Ruft einen Wert ab, der angibt, ob die Methode eine generische Methode ist.
IsGenericMethodDefinition	Ruft einen Wert ab, der angibt, ob das aktuelle MethodBuilder-Objekt die Definition einer generischen Methode darstellt.
IsHideBySig	Ruft einen Wert ab, der angibt, ob nur ein Member derselben Art mit einer identischen Signatur in der abgeleiteten Klasse verborgen ist. (Geerbt von MethodBase)
IsPrivate	Ruft einen Wert ab, der angibt, ob es sich um einen privaten Member handelt. (Geerbt von MethodBase)
IsPublic	Ruft einen Wert ab, der angibt, ob dies eine öffentliche Methode ist. (Geerbt von MethodBase)
IsSecurityCritical	Löst in allen Fällen eine NotSupportedException aus.
IsSecuritySafeCritical	Löst in allen Fällen eine NotSupportedException aus.
IsSecurityTransparent	Löst in allen Fällen eine NotSupportedException aus.
IsSpecialName	Ruft einen Wert ab, der angibt, ob diese Methode einen besonderen Namen hat. (Geerbt von MethodBase)
IsStatic	Ruft einen Wert ab, der angibt, ob die Methode static ist. (Geerbt von MethodBase)
IsVirtual	Ruft einen Wert ab, der angibt, ob die Methode virtual ist. (Geerbt von MethodBase)
MemberType	Ruft einen MemberTypes-Wert ab, der angibt, dass dieser Member eine Methode ist. (Geerbt von MethodInfo)
MetadataToken	Ruft ein Token ab, das das aktuelle dynamische Modul in den Metadaten angibt.
MethodHandle	Ruft das interne Handle für die Methode ab. Verwenden Sie dieses Handle, um auf das zugrunde liegende Metadatenhandle zuzugreifen.
MethodImplementationFlags	Ruft die MethodImplAttributes-Flags ab, die die Attribute einer Methodenimplementierung angeben. (Geerbt von MethodBase)
Module	Ruft das Modul ab, in dem die aktuelle Methode definiert wird.
Name	Ruft den Namen dieser Methode ab.
ReflectedType	Ruft die Klasse ab, die bei der Reflektion verwendet wurde, um dieses Objekt abzurufen.
ReturnParameter	Ruft ein ParameterInfo-Objekt ab, das Informationen zum Rückgabetyp der Methode enthält, z: B. ob der Rückgabetyp benutzerdefinierte Modifizierer hat.
ReturnType	Ruft den Rückgabetyp der Methode ab, die von diesem MethodBuilder dargestellt wird.
ReturnTypeCustomAttributes	Gibt die benutzerdefinierten Attribute des Rückgabetyps der Methode zurück.

Methoden

CreateDelegate(Type)	Erstellt aus dieser Methode einen Delegaten vom angegebenen Typ. (Geerbt von MethodInfo)
CreateDelegate(Type, Object)	Erstellt einen Delegaten vom angegebenen Typ mit dem angegebenen Ziel aus dieser Methode. (Geerbt von MethodInfo)
CreateDelegate<T>()	Erstellt aus dieser Methode einen Delegaten vom Typ T. (Geerbt von MethodInfo)
CreateDelegate<T>(Object)	Erstellt einen Delegaten vom Typ T mit dem angegebenen Ziel aus dieser Methode. (Geerbt von MethodInfo)
DefineGenericParameters(String[])	Legt die Anzahl von generischen Typparametern für die aktuelle Methode fest, gibt deren Namen an und gibt ein Array von GenericTypeParameterBuilder-Objekten zurück, das dazu verwendet werden kann, deren Einschränkungen zu definieren.
DefineGenericParametersCore(String[])	Legt beim Überschreiben in einer abgeleiteten Klasse die Anzahl der generischen Typparameter für die aktuelle Methode fest, gibt deren Namen an und gibt ein Array von GenericTypeParameterBuilder Objekten zurück, die zum Definieren ihrer Einschränkungen verwendet werden können.
DefineParameter(Int32, ParameterAttributes, String)	Legt die Parameterattribute und den Namen eines Parameters dieser Methode oder des Rückgabewerts dieser Methode fest. Gibt einen ParameterBuilder zurück, mit dem benutzerdefinierte Attribute angewendet werden können.
DefineParameterCore(Int32, ParameterAttributes, String)	Definiert beim Überschreiben in einer abgeleiteten Klasse einen Parameter oder Rückgabeparameter für diese Methode.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dieser Instanz ist.
GetBaseDefinition()	Gibt die Basisimplementierung für eine Methode zurück.
GetCustomAttributes(Boolean)	Gibt alle für diese Methode definierten benutzerdefinierten Attribute zurück.
GetCustomAttributes(Type, Boolean)	Gibt die benutzerdefinierten Attribute zurück, die durch den angegebenen Typ identifiziert werden.
GetCustomAttributesData()	Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten zu den Attributen darstellen, die auf den Zielmember angewendet wurden. (Geerbt von MemberInfo)
GetGenericArguments()	Gibt ein Array von GenericTypeParameterBuilder-Objekten zurück, die die Typparameter der Methode darstellen, wenn diese generisch ist.
GetGenericMethodDefinition()	Gibt diese Methode zurück.
GetHashCode()	Ruft den Hashcode für diese Methode ab.
GetILGenerator()	Gibt einen ILGenerator mit der standardmäßigen MSIL-Streamgröße (Microsoft Intermediate Language) von 64 Bytes für diese Methode zurück.
GetILGenerator(Int32)	Gibt einen ILGenerator mit der angegebenen MSIL-Streamgröße (Microsoft Intermediate Language) für diese Methode zurück.
GetILGeneratorCore(Int32)	Ruft beim Überschreiben in einer abgeleiteten Klasse einen ILGenerator ab, der zum Ausgeben eines Methodentexts für diese Methode verwendet werden kann.
GetMethodBody()	Ruft beim Überschreiben in einer abgeleiteten Klasse ein MethodBody-Objekt ab, das den Zugriff auf den MSIL-Stream, auf lokale Variablen und auf Ausnahmen für die aktuelle Methode ermöglicht. (Geerbt von MethodBase)
GetMethodImplementationFlags()	Gibt die Implementierungsflags für die Methode zurück.
GetParameters()	Gibt die Parameter dieser Methode zurück.
GetType()	Ermittelt die Attribute einer Methode und ermöglicht den Zugriff auf die Metadaten der Methode. (Geerbt von MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Definiert eine Methode (oder einen Konstruktor) für eine dynamischen Klasse und stellt diese(n) dar. (Geerbt von MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Ruft dynamisch und entsprechend den Einschränkungen des angegebenen Binders die Methode auf, die durch diese Instanz für das angegebene Objekt reflektiert wird. Übergibt dabei die angegebenen Parameter.
Invoke(Object, Object[])	Ruft die Methode oder den Konstruktor, die/der durch die aktuelle Instanz dargestellt wird, mit den angegebenen Parametern auf. (Geerbt von MethodInfo)
IsDefined(Type, Boolean)	Überprüft, ob der Typ des angegebenen benutzerdefinierten Attributs definiert ist.
MakeGenericMethod(Type[])	Gibt eine aus der aktuellen generischen Methodendefinition mit den angegebenen generischen Typargumenten konstruierte generische Methode zurück.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Legt ein benutzerdefiniertes Attribut mithilfe eines angegebenen benutzerdefinierten Attribut-BLOBs fest.
SetCustomAttribute(CustomAttributeBuilder)	Legt ein benutzerdefiniertes Attribut mithilfe eines benutzerdefinierten Attribut-Generators fest.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Legt beim Überschreiben in einer abgeleiteten Klasse ein benutzerdefiniertes Attribut für diese Assembly fest.
SetImplementationFlags(MethodImplAttributes)	Legt die Implementierungsflags für diese Methode fest.
SetImplementationFlagsCore(MethodImplAttributes)	Legt beim Überschreiben in einer abgeleiteten Klasse die Implementierungsflags für diese Methode fest.
SetParameters(Type[])	Legt die Anzahl und Typen der Parameter für eine Methode fest.
SetReturnType(Type)	Legt den Rückgabetyp der Methode fest.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Legt die Methodensignatur fest, einschließlich des Rückgabetyps, der Parametertypen und der erforderlichen und optionalen benutzerdefinierten Modifizierer für den Rückgabetyp und die Parametertypen.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Legt beim Überschreiben in einer abgeleiteten Klasse die Methodensignatur fest, einschließlich des Rückgabetyps, der Parametertypen und der erforderlichen und optionalen benutzerdefinierten Modifizierer des Rückgabetyps und der Parametertypen.
ToString()	Gibt diese MethodBuilder-Instanz als Zeichenfolge zurück.

Erweiterungsmethoden

GetCustomAttribute(MemberInfo, Type)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird.
GetCustomAttribute(MemberInfo, Type, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird, und überprüft optional die Vorgänger dieses Members.
GetCustomAttribute<T>(MemberInfo)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird.
GetCustomAttribute<T>(MemberInfo, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird, und überprüft optional die Vorgänger dieses Members.
GetCustomAttributes(MemberInfo)	Ruft eine Auflistung benutzerdefinierter Attribute ab, die für einen angegebenen Member angewendet werden.
GetCustomAttributes(MemberInfo, Boolean)	Ruft eine Auflistung benutzerdefinierter Attribute ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.
GetCustomAttributes(MemberInfo, Type)	Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für eine angegebenen Member angewendet werden.
GetCustomAttributes(MemberInfo, Type, Boolean)	Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.
GetCustomAttributes<T>(MemberInfo)	Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für eine angegebenen Member angewendet werden.
GetCustomAttributes<T>(MemberInfo, Boolean)	Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.
IsDefined(MemberInfo, Type)	Gibt an, ob irgend welche benutzerdefinierten Attribute eines bestimmten Typs auf eines angegebenen Members angewendet werden.
IsDefined(MemberInfo, Type, Boolean)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf einen angegebenen Member und optional auf dessen Vorgänger angewendet werden.
GetMetadataToken(MemberInfo)	Ruft ein Metadatentoken für das angegebene Element ab, falls verfügbar.
HasMetadataToken(MemberInfo)	Gibt einen Wert zurück, der angibt, ob ein Metadatentoken für das angegebene Element verfügbar ist.
GetBaseDefinition(MethodInfo)	Definiert eine Methode (oder einen Konstruktor) für eine dynamischen Klasse und stellt diese(n) dar.
GetRuntimeBaseDefinition(MethodInfo)	Ruft ein Objekt ab, das die angegebene Methode der direkten oder indirekten Basisklasse darstellt, in der die Methode am Anfang deklariert wurde.