MethodBuilder Klasse

Referenz

Definition

Namespace:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paket:: System.Reflection.Emit v4.7.0

Quelle:: MethodBuilder.cs

Quelle:: MethodBuilder.cs

Quelle:: MethodBuilder.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

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

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

public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder

public sealed class MethodBuilder : System.Reflection.MethodInfo

public abstract class MethodBuilder : System.Reflection.MethodInfo

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder

type MethodBuilder = class
    inherit MethodInfo

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder

Public NotInheritable Class MethodBuilder
Inherits MethodInfo

Public MustInherit Class MethodBuilder
Inherits MethodInfo

Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder

Vererbung: Object

MemberInfo

MethodBase

MethodInfo
MethodBuilder

Attribute: ClassInterfaceAttribute ComVisibleAttribute

Implementiert: _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 Zusätzliche 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.
ContainsGenericParameters	Ruft einen Wert ab, der angibt, ob eine generische Methode nicht zugewiesene generische Typparameter enthält. (Geerbt von MethodInfo)
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.
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.
IsGenericMethod	Ruft einen Wert ab, der angibt, ob die aktuelle Methode eine generische Methode ist. (Geerbt von MethodInfo)
IsGenericMethodDefinition	Ruft einen Wert ab, der angibt, ob das aktuelle MethodBuilder-Objekt die Definition einer generischen Methode darstellt.
IsGenericMethodDefinition	Ruft einen Wert ab, der angibt, ob die aktuelle MethodInfo die Definition einer generischen Methode darstellt. (Geerbt von MethodInfo)
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.
IsSecurityCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitsrelevant oder sicherheitsrelevant und sicher zugänglich ist und daher wichtige Vorgänge ausführen darf. (Geerbt von MethodBase)
IsSecuritySafeCritical	Löst in allen Fällen eine NotSupportedException aus.
IsSecuritySafeCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitsrelevant ist, d. h., ob sie bzw. er wichtige Vorgänge ausführen darf und ob von transparentem Code darauf zugegriffen werden kann. (Geerbt von MethodBase)
IsSecurityTransparent	Löst in allen Fällen eine NotSupportedException aus.
IsSecurityTransparent	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitstransparent ist und daher keine wichtigen Vorgänge ausführen kann. (Geerbt von MethodBase)
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.
MetadataToken	Ruft einen Wert ab, der ein Metadatenelement identifiziert. (Geerbt von MemberInfo)
MethodHandle	Ruft das interne Handle für die Methode ab. Verwenden Sie dieses Handle, um auf das zugrunde liegende Metadatenhandle zuzugreifen.
MethodHandle	Ruft ein Handle für die interne Metadatendarstellung einer Methode ab. (Geerbt von MethodBase)
MethodImplementationFlags	Definiert eine Methode (oder einen Konstruktor) für eine dynamischen Klasse und stellt diese(n) dar.
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.
Module	Ruft das Modul ab, in dem der Typ definiert ist, der den von der aktuellen MemberInfo-Klasse dargestellten Member deklariert. (Geerbt von MemberInfo)
Name	Ruft den Namen dieser Methode ab.
ReflectedType	Ruft die Klasse ab, die bei der Reflektion verwendet wurde, um dieses Objekt abzurufen.
ReflectedType	Ruft das Klassenobjekt ab, mit dem diese Instanz von `MemberInfo` abgerufen wurde. (Geerbt von MemberInfo)
ReturnParameter	Ruft ein ParameterInfo-Objekt ab, das Informationen zum Rückgabetyp der Methode enthält, z: B. ob der Rückgabetyp benutzerdefinierte Modifizierer hat.
ReturnParameter	Ruft ein ParameterInfo-Objekt ab, das Informationen zum Rückgabetyp der Methode enthält, z: B. ob der Rückgabetyp benutzerdefinierte Modifizierer hat. (Geerbt von MethodInfo)
ReturnType	Ruft den Rückgabetyp der Methode ab, die von diesem MethodBuilder dargestellt wird.
ReturnType	Ruft den Rückgabetyp dieser Methode ab. (Geerbt von MethodInfo)
ReturnTypeCustomAttributes	Gibt die benutzerdefinierten Attribute des Rückgabetyps der Methode zurück.
ReturnTypeCustomAttributes	Ruft die benutzerdefinierten Attribute für den Rückgabetyp ab. (Geerbt von MethodInfo)
Signature	Ruft die Signatur der Methode ab.

Methoden

AddDeclarativeSecurity(SecurityAction, PermissionSet)	Fügt dieser Methode deklarative Sicherheit hinzu.
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 Delegat vom Typ `T` mit dem angegebenen Ziel aus dieser Methode. (Geerbt von MethodInfo)
CreateMethodBody(Byte[], Int32)	Erstellt den Text der Methode unter Verwendung eines angegebenen Bytearrays von MSIL-Anweisungen (Microsoft Intermediate Language).
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 Objekten zurück, mit dem GenericTypeParameterBuilder ihre Einschränkungen definiert 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.
GetBaseDefinition()	Gibt beim Überschreiben in einer abgeleiteten Klasse das MethodInfo-Objekt für die Methode in der direkten oder indirekten Basisklasse zurück, in der die durch diese Instanz dargestellte Methode zuerst deklariert wurde. (Geerbt von MethodInfo)
GetCustomAttributes(Boolean)	Gibt alle für diese Methode definierten benutzerdefinierten Attribute zurück.
GetCustomAttributes(Boolean)	Gibt beim Überschreiben in einer abgeleiteten Klasse ein Array mit allen benutzerdefinierten Attributen zurück, die auf diesen Member angewendet wurden. (Geerbt von MemberInfo)
GetCustomAttributes(Type, Boolean)	Gibt die benutzerdefinierten Attribute zurück, die durch den angegebenen Typ identifiziert werden.
GetCustomAttributes(Type, Boolean)	Gibt beim Überschreiben in einer abgeleiteten Klasse ein Array aus benutzerdefinierten Attributen zurück, die auf diesen Member angewendet und von Type identifiziert wurden. (Geerbt von MemberInfo)
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.
GetGenericArguments()	Gibt ein Array von Type-Objekten zurück, die die Typargumente einer generischen Methode oder die Typparameter einer generischen Methodendefinition darstellen. (Geerbt von MethodInfo)
GetGenericMethodDefinition()	Gibt diese Methode zurück.
GetGenericMethodDefinition()	Gibt ein MethodInfo-Objekt zurück, das eine generische Methodendefinition darstellt, aus der die aktuelle Methode konstruiert werden kann. (Geerbt von MethodInfo)
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.
GetMethodImplementationFlags()	Erstellt beim Überschreiben in einer abgeleiteten Klasse die MethodImplAttributes-Flags. (Geerbt von MethodBase)
GetModule()	Gibt einen Verweis auf das Modul zurück, das diese Methode enthält.
GetParameters()	Gibt die Parameter dieser Methode zurück.
GetToken()	Gibt das `MethodToken` zurück, das das Token für diese Methode darstellt.
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, BindingFlags, Binder, Object[], CultureInfo)	Ruft beim Überschreiben in einer abgeleiteten Klasse die reflektierte Methode oder den reflektierten Konstruktor mit den angegebenen Parametern auf. (Geerbt von MethodBase)
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.
IsDefined(Type, Boolean)	Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob ein oder mehrere Attribute des angegebenen Typs oder seiner abgeleiteten Typen auf diesen Member angewendet werden. (Geerbt von MemberInfo)
MakeGenericMethod(Type[])	Gibt eine aus der aktuellen generischen Methodendefinition mit den angegebenen generischen Typargumenten konstruierte generische Methode zurück.
MakeGenericMethod(Type[])	Ersetzt die Typparameter der aktuellen generischen Methodendefinition durch die Elemente eines Arrays von Typen und gibt ein MethodInfo-Objekt zurück, das die sich ergebende konstruierte Methode darstellt. (Geerbt von MethodInfo)
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.
SetMarshal(UnmanagedMarshal)	Veraltet. Legt die Marshallinginformationen für den Rückgabetyp dieser Methode fest.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Erstellt den Text der Methode unter Verwendung eines angegebenen Bytearrays von MSIL-Anweisungen (Microsoft Intermediate Language).
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.
SetSymCustomAttribute(String, Byte[])	Legen Sie ein symbolisches benutzerdefiniertes Attribut mithilfe eines BLOBs fest.
ToString()	Gibt diese `MethodBuilder`-Instanz als Zeichenfolge zurück.

Explizite Schnittstellenimplementierungen

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MemberInfo)
_MemberInfo.GetType()	Ruft ein Type-Objekt ab, das die MemberInfo-Klasse darstellt. (Geerbt von MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können. (Geerbt von MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit. (Geerbt von MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MethodBase)
_MethodBase.GetType()	Eine Beschreibung dieses Elements finden Sie unter GetType(). (Geerbt von MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können. (Geerbt von MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit. (Geerbt von MethodBase)
_MethodBase.IsAbstract	Eine Beschreibung dieses Elements finden Sie unter IsAbstract. (Geerbt von MethodBase)
_MethodBase.IsAssembly	Eine Beschreibung dieses Elements finden Sie unter IsAssembly. (Geerbt von MethodBase)
_MethodBase.IsConstructor	Eine Beschreibung dieses Elements finden Sie unter IsConstructor. (Geerbt von MethodBase)
_MethodBase.IsFamily	Eine Beschreibung dieses Elements finden Sie unter IsFamily. (Geerbt von MethodBase)
_MethodBase.IsFamilyAndAssembly	Eine Beschreibung dieses Elements finden Sie unter IsFamilyAndAssembly. (Geerbt von MethodBase)
_MethodBase.IsFamilyOrAssembly	Eine Beschreibung dieses Elements finden Sie unter IsFamilyOrAssembly. (Geerbt von MethodBase)
_MethodBase.IsFinal	Eine Beschreibung dieses Elements finden Sie unter IsFinal. (Geerbt von MethodBase)
_MethodBase.IsHideBySig	Eine Beschreibung dieses Elements finden Sie unter IsHideBySig. (Geerbt von MethodBase)
_MethodBase.IsPrivate	Eine Beschreibung dieses Elements finden Sie unter IsPrivate. (Geerbt von MethodBase)
_MethodBase.IsPublic	Eine Beschreibung dieses Elements finden Sie unter IsPublic. (Geerbt von MethodBase)
_MethodBase.IsSpecialName	Eine Beschreibung dieses Elements finden Sie unter IsSpecialName. (Geerbt von MethodBase)
_MethodBase.IsStatic	Eine Beschreibung dieses Elements finden Sie unter IsStatic. (Geerbt von MethodBase)
_MethodBase.IsVirtual	Eine Beschreibung dieses Elements finden Sie unter IsVirtual. (Geerbt von MethodBase)
_MethodBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.
_MethodBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.
_MethodBuilder.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).
_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MethodInfo)
_MethodInfo.GetType()	Stellt Zugriff auf die GetType()-Methode aus COM bereit. (Geerbt von MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können. (Geerbt von MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)	Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Geerbt von MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit. (Geerbt von MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Gibt – mit Ausnahme benannter Attribute – ein Array mit allen für diesen Member definierten benutzerdefinierten Attributen zurück – oder ein leeres Array , wenn keine benutzerdefinierten Attribute vorhanden sind. (Geerbt von MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Gibt ein Array mit für diesen Member definierten benutzerdefinierten Attributen zurück – identifiziert nach Typ – oder ein leeres Array , wenn keine benutzerdefinierten Attribute vorhanden sind. (Geerbt von MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Gibt an, ob mindestens eine Instanz von `attributeType` für diesen Member definiert ist. (Geerbt von MemberInfo)

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.

Gilt für:

Freigeben über