MethodBuilder Klasse

Definition

Namespace:: System.Reflection.Emit

Assemblys:: netstandard.dll, System.Reflection.Emit.dll

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: MethodBuilder.cs

Quelle:: MethodBuilder.cs

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 und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse dar.

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

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

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

public abstract class MethodBuilder : System.Reflection.MethodInfo

public sealed 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 MustInherit Class MethodBuilder
Inherits MethodInfo

Public NotInheritable 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 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

Die MethodBuilder Klasse wird verwendet, um eine Methode in allgemeiner Zwischensprache (CIL) vollständig zu beschreiben, einschließlich Name, Attribute, Signatur und Methodentext. Er wird in Verbindung mit der Klasse TypeBuilder verwendet, um Klassen zur Laufzeit zu erstellen.

Sie können Reflection emit verwenden, um globale Methoden zu definieren und um Methoden als Mitglieder des Typs zu definieren. Die APIs, die Methoden definieren, geben Objekte zurück MethodBuilder .

Globale Methoden

Eine globale Methode wird mithilfe der ModuleBuilder.DefineGlobalMethod Methode definiert, die ein MethodBuilder Objekt zurückgibt.

Globale Methoden müssen statisch sein. Wenn ein dynamisches Modul globale Methoden enthält, muss die ModuleBuilder.CreateGlobalFunctions Methode aufgerufen werden, bevor das dynamische Modul oder die enthaltende dynamische Assembly beibehalten wird, da die Common Language Runtime das Beheben des dynamischen Moduls verzögert, bis alle globalen Funktionen definiert wurden.

Eine globale systemeigene Methode wird mithilfe der ModuleBuilder.DefinePInvokeMethod Methode definiert. Plattformaufrufmethoden (PInvoke) dürfen nicht abstrakt oder virtuell deklariert werden. Die Laufzeit legt das MethodAttributes.PinvokeImpl Attribut für eine Plattformaufrufmethode fest.

Methoden als Elemente von Typen

Eine Methode wird mithilfe der TypeBuilder.DefineMethod Methode, die ein MethodBuilder Objekt zurückgibt, als Typmemm definiert.

Die DefineParameter Methode wird verwendet, um den Namen und die Parameterattribute eines Parameters oder des Rückgabewerts festzulegen. Das ParameterBuilder von dieser Methode zurückgegebene Objekt stellt einen Parameter oder den Rückgabewert dar. Das ParameterBuilder Objekt kann verwendet werden, um das Marshalling festzulegen, den Konstantenwert festzulegen und benutzerdefinierte Attribute anzuwenden.

Attribute

Elemente der MethodAttributes Enumeration definieren den genauen Charakter einer dynamischen Methode.

Statische Methoden werden mithilfe des MethodAttributes.Static Attributs angegeben.
Endgültige Methoden (Methoden, die nicht außer Kraft gesetzt werden können) werden mithilfe des MethodAttributes.Final Attributs angegeben.
Virtuelle Methoden werden mithilfe des MethodAttributes.Virtual Attributs angegeben.
Abstrakte Methoden werden mithilfe des MethodAttributes.Abstract Attributs angegeben.
Mehrere Attribute bestimmen die Methodensichtbarkeit. Siehe die Beschreibung der MethodAttributes-Auflistung.
Methoden, die überladene Operatoren implementieren, müssen das MethodAttributes.SpecialName Attribut festlegen.
Finalizer müssen das MethodAttributes.SpecialName Attribut festlegen.

Bekannte Probleme

Obwohl MethodBuilder von MethodInfo abgeleitet wird, werden einige der in der MethodInfo-Klasse definierten abstrakten Methoden nicht vollständig in MethodBuilder implementiert. Diese MethodBuilder-Methoden verursachen die NotSupportedException. Beispielsweise ist die Methode MethodBuilder.Invoke nicht vollständig implementiert. Sie können über diese Methoden nachdenken, indem Sie den eingeschlossenen Typ mithilfe der Methoden Type.GetType oder Assembly.GetType abrufen.
Benutzerdefinierte Modifizierer werden unterstützt.

Konstruktoren

Name	Beschreibung
MethodBuilder()	Initialisiert eine neue Instanz der MethodBuilder-Klasse.

Eigenschaften

Name	Beschreibung
Attributes	Ruft die Attribute für diese Methode ab.
CallingConvention	Gibt die aufrufende Konvention der Methode zurück.
ContainsGenericParameters	Wird für diesen Typ nicht unterstützt.
CustomAttributes	Ruft eine Auflistung ab, die die benutzerdefinierten Attribute dieses Elements enthält. (Geerbt von MemberInfo)
DeclaringType	Gibt den Typ zurück, der diese Methode deklariert.
InitLocals	Dient zum Abrufen oder Festlegen eines booleschen Werts, der angibt, ob die lokalen Variablen in dieser Methode null initialisiert sind. Der Standardwert dieser Eigenschaft ist `true`.
InitLocalsCore	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen oder festgelegt, der angibt, ob die lokalen Variablen in dieser Methode nullinitialisiert sind.
IsAbstract	Ruft einen Wert ab, der angibt, ob die Methode abstrakt ist. (Geerbt von MethodBase)
IsAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder des Konstruktors beschrieben Assemblywird; d. h. die Methode oder der Konstruktor ist höchstens für andere Typen in derselben Assembly sichtbar und ist für abgeleitete Typen außerhalb der Assembly nicht sichtbar. (Geerbt von MethodBase)
IsCollectible	Ruft einen Wert ab, der angibt, ob dieses MemberInfo Objekt auf eine oder mehrere Assemblys verweist, die in einem Sammelobjekt AssemblyLoadContextgespeichert sind. (Geerbt von MemberInfo)
IsConstructedGenericMethod	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse dar.
IsConstructedGenericMethod	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse 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 oder des Konstruktors von Family; d. h. die Methode oder der Konstruktor nur innerhalb ihrer Klasse und abgeleiteten Klassen sichtbar ist. (Geerbt von MethodBase)
IsFamilyAndAssembly	Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode oder des Konstruktors beschrieben FamANDAssemwird; d. h. die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, aber nur, wenn sie sich in derselben Assembly befinden. (Geerbt von MethodBase)
IsFamilyOrAssembly	Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder des Konstruktors beschrieben FamORAssemwird; d. h. die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, wo immer sie sich befinden, und von Klassen in derselben Assembly. (Geerbt von MethodBase)
IsFinal	Ruft einen Wert ab, der angibt, ob diese Methode ist `final`. (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 Objekt die Definition einer generischen MethodBuilder Methode darstellt.
IsHideBySig	Ruft einen Wert ab, der angibt, ob nur ein Element derselben Art mit genau derselben Signatur in der abgeleiteten Klasse ausgeblendet ist. (Geerbt von MethodBase)
IsPrivate	Ruft einen Wert ab, der angibt, ob dieses Element privat ist. (Geerbt von MethodBase)
IsPublic	Ruft einen Wert ab, der angibt, ob es sich um eine öffentliche Methode handelt. (Geerbt von MethodBase)
IsSecurityCritical	Löst in allen Fällen ein NotSupportedException .
IsSecurityCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor sicherheitskritisch oder sicherheitssicher auf der aktuellen Vertrauensebene ist und daher kritische Vorgänge ausführen kann. (Geerbt von MethodBase)
IsSecuritySafeCritical	Löst in allen Fällen ein NotSupportedException .
IsSecuritySafeCritical	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor sicherheitssicher auf der aktuellen Vertrauensebene ist; d. h., ob sie kritische Vorgänge ausführen kann und durch transparenten Code darauf zugegriffen werden kann. (Geerbt von MethodBase)
IsSecurityTransparent	Löst in allen Fällen ein NotSupportedException .
IsSecurityTransparent	Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der Konstruktor auf der aktuellen Vertrauensebene transparent ist und daher keine kritischen Vorgänge ausführen kann. (Geerbt von MethodBase)
IsSpecialName	Ruft einen Wert ab, der angibt, ob diese Methode einen speziellen Namen hat. (Geerbt von MethodBase)
IsStatic	Ruft einen Wert ab, der angibt, ob die Methode ist `static`. (Geerbt von MethodBase)
IsVirtual	Ruft einen Wert ab, der angibt, ob die Methode ist `virtual`. (Geerbt von MethodBase)
MemberType	Ruft einen MemberTypes Wert ab, der angibt, dass dieses Element eine Methode ist. (Geerbt von MethodInfo)
MetadataToken	Ruft ein Token ab, das das aktuelle dynamische Modul in Metadaten identifiziert.
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.
MethodImplementationFlags	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse 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, der das durch die aktuelle MemberInfo Darstellung dargestellte Element deklariert, definiert ist. (Geerbt von MemberInfo)
Name	Ruft den Namen dieser Methode ab.
ReflectedType	Ruft die Klasse ab, die in Spiegelung 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 enthält.
ReturnType	Ruft den Rückgabetyp der durch diese MethodBuilderdargestellten Methode ab.
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

Name	Beschreibung
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Fügt dieser Methode deklarative Sicherheit hinzu.
CreateDelegate(Type, Object)	Erstellt einen Delegaten des angegebenen Typs mit dem angegebenen Ziel aus dieser Methode. (Geerbt von MethodInfo)
CreateDelegate(Type)	Erstellt einen Delegaten des angegebenen Typs aus dieser Methode. (Geerbt von MethodInfo)
CreateDelegate<T>()	Erstellt einen Delegat vom Typ `T` aus dieser Methode. (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 Textkörper der Methode mithilfe eines bereitgestellten Bytearrays Microsoft MSIL-Anweisungen (Intermediate Language).
DefineGenericParameters(String[])	Legt 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.
DefineGenericParametersCore(String[])	Wenn eine abgeleitete Klasse überschrieben wird, wird die Anzahl der generischen Typparameter für die aktuelle Methode festgelegt, deren Namen angegeben und ein Array von GenericTypeParameterBuilder Objekten zurückgegeben, das zum Definieren ihrer Einschränkungen verwendet werden kann.
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, der zum Anwenden benutzerdefinierter Attribute verwendet werden kann.
DefineParameterCore(Int32, ParameterAttributes, String)	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, definiert sie einen Parameter oder Rückgabeparameter für diese Methode.
Equals(Object)	Bestimmt, ob das angegebene Objekt dieser Instanz entspricht.
GetBaseDefinition()	Gibt die Basisimplementierung für eine Methode zurück.
GetBaseDefinition()	Wenn eine abgeleitete Klasse überschrieben wird, wird das MethodInfo Objekt für die Methode für die direkte oder indirekte Basisklasse zurückgegeben, 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(Type, Boolean)	Gibt die vom angegebenen Typ identifizierten benutzerdefinierten Attribute zurück.
GetCustomAttributesData()	Gibt eine Liste von CustomAttributeData Objekten zurück, die Daten zu den Attributen darstellen, die auf das Zielelement angewendet wurden. (Geerbt von MemberInfo)
GetGenericArguments()	Gibt ein Array von GenericTypeParameterBuilder Objekten zurück, die die Typparameter der Methode darstellen, wenn es generisch ist.
GetGenericMethodDefinition()	Gibt diese Methode zurück.
GetHashCode()	Ruft den Hashcode für diese Methode ab.
GetILGenerator()	Gibt einen `ILGenerator` für diese Methode mit einer Standarddatenstromgröße für Microsoft Zwischensprache (MSIL) von 64 Byte zurück.
GetILGenerator(Int32)	Gibt eine `ILGenerator` für diese Methode mit der angegebenen Microsoft Zwischensprache (MSIL)-Datenstromgröße zurück.
GetILGeneratorCore(Int32)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird ein ILGenerator , der zum Ausgeben eines Methodentexts für diese Methode verwendet werden kann.
GetMethodBody()	Wenn eine abgeleitete Klasse außer Kraft gesetzt wird, ruft ein MethodBody Objekt ab, das Zugriff auf den MSIL-Datenstrom, lokale Variablen und Ausnahmen für die aktuelle Methode ermöglicht. (Geerbt von MethodBase)
GetMethodImplementationFlags()	Gibt die Implementierungskennzeichnungen für die Methode zurück.
GetMethodImplementationFlags()	Wenn sie in einer abgeleiteten Klasse überschrieben werden, werden die MethodImplAttributes Flags zurückgegeben. (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` Token für diese Methode zurück.
GetType()	Ermittelt die Attribute einer Methode und bietet Zugriff auf Methodenmetadaten. (Geerbt von MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse dar. (Geerbt von MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Ruft die von dieser Instanz für das angegebene Objekt wiedergegebene Methode dynamisch auf, übergibt die angegebenen Parameter und unter den Einschränkungen des angegebenen Ordners.
Invoke(Object, Object[])	Ruft die von der aktuellen Instanz dargestellte Methode oder den Konstruktor mithilfe der angegebenen Parameter auf. (Geerbt von MethodInfo)
IsDefined(Type, Boolean)	Überprüft, ob der angegebene benutzerdefinierte Attributtyp definiert ist.
MakeGenericMethod(Type[])	Gibt eine generische Methode aus der aktuellen generischen Methodendefinition mithilfe der angegebenen generischen Typargumente zurück.
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Legt ein benutzerdefiniertes Attribut mithilfe eines angegebenen benutzerdefinierten Attribut-BLOB fest.
SetCustomAttribute(CustomAttributeBuilder)	Legt ein benutzerdefiniertes Attribut mithilfe eines benutzerdefinierten Attribut-Generators fest.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird ein benutzerdefiniertes Attribut für diese Assembly festgelegt.
SetImplementationFlags(MethodImplAttributes)	Legt die Implementierungskennzeichnungen für diese Methode fest.
SetImplementationFlagsCore(MethodImplAttributes)	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, werden die Implementierungskennzeichnungen für diese Methode festgelegt.
SetMarshal(UnmanagedMarshal)	Veraltet. Legt Marshallinginformationen für den Rückgabetyp dieser Methode fest.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Erstellt den Textkörper der Methode mithilfe eines angegebenen Bytearrays Microsoft MSIL-Anweisungen (Intermediate Language).
SetParameters(Type[])	Legt die Anzahl und Die Typen von Parametern 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 der Rückgabetyp- und Parametertypen.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, wird die Methodensignatur festgelegt, einschließlich des Rückgabetyps, der Parametertypen sowie 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

Name	Beschreibung
_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)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (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 Mitglieds 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)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von MethodBase)
_MethodBase.IsAbstract	Eine Beschreibung dieses Mitglieds finden Sie unter IsAbstract. (Geerbt von MethodBase)
_MethodBase.IsAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsAssembly. (Geerbt von MethodBase)
_MethodBase.IsConstructor	Eine Beschreibung dieses Mitglieds finden Sie unter IsConstructor. (Geerbt von MethodBase)
_MethodBase.IsFamily	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamily. (Geerbt von MethodBase)
_MethodBase.IsFamilyAndAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamilyAndAssembly. (Geerbt von MethodBase)
_MethodBase.IsFamilyOrAssembly	Eine Beschreibung dieses Mitglieds finden Sie unter IsFamilyOrAssembly. (Geerbt von MethodBase)
_MethodBase.IsFinal	Eine Beschreibung dieses Mitglieds finden Sie unter IsFinal. (Geerbt von MethodBase)
_MethodBase.IsHideBySig	Eine Beschreibung dieses Mitglieds finden Sie unter IsHideBySig. (Geerbt von MethodBase)
_MethodBase.IsPrivate	Eine Beschreibung dieses Mitglieds finden Sie unter IsPrivate. (Geerbt von MethodBase)
_MethodBase.IsPublic	Eine Beschreibung dieses Mitglieds finden Sie unter IsPublic. (Geerbt von MethodBase)
_MethodBase.IsSpecialName	Eine Beschreibung dieses Mitglieds finden Sie unter IsSpecialName. (Geerbt von MethodBase)
_MethodBase.IsStatic	Eine Beschreibung dieses Mitglieds finden Sie unter IsStatic. (Geerbt von MethodBase)
_MethodBase.IsVirtual	Eine Beschreibung dieses Mitglieds 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)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden.
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Geerbt von MethodInfo)
_MethodInfo.GetType()	Bietet Zugriff auf die GetType() Methode von COM. (Geerbt von MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Ruft die Typinformationen für ein Objekt ab, mit denen 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)	Bietet Zugriff auf Eigenschaften und Methoden, die von einem Objekt verfügbar gemacht werden. (Geerbt von MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Gibt ein Array aller benutzerdefinierten Attribute zurück, die für dieses Element definiert sind, ohne benannte Attribute oder ein leeres Array, wenn keine benutzerdefinierten Attribute vorhanden sind. (Geerbt von MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Gibt ein Array von benutzerdefinierten Attributen zurück, die für dieses Element definiert sind, identifiziert nach Typ oder ein leeres Array, wenn keine benutzerdefinierten Attribute dieses Typs vorhanden sind. (Geerbt von MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Gibt an, ob eine oder mehrere Instanzen dieses `attributeType` Elements definiert sind. (Geerbt von MemberInfo)

Erweiterungsmethoden

Name	Beschreibung
GetBaseDefinition(MethodInfo)	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse dar.
GetCustomAttribute(MemberInfo, Type, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der auf ein angegebenes Element angewendet wird, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttribute(MemberInfo, Type)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Element angewendet wird.
GetCustomAttribute<T>(MemberInfo, Boolean)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der auf ein angegebenes Element angewendet wird, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttribute<T>(MemberInfo)	Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, das auf ein angegebenes Element angewendet wird.
GetCustomAttributes(MemberInfo, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes(MemberInfo, Type, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes(MemberInfo, Type)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden.
GetCustomAttributes(MemberInfo)	Ruft eine Auflistung von benutzerdefinierten Attributen ab, die auf ein angegebenes Element angewendet werden.
GetCustomAttributes<T>(MemberInfo, Boolean)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden, und überprüft optional die Vorgänger dieses Elements.
GetCustomAttributes<T>(MemberInfo)	Ruft eine Auflistung von benutzerdefinierten Attributen eines angegebenen Typs ab, die auf ein angegebenes Element angewendet werden.
GetMetadataToken(MemberInfo)	Ruft ein Metadatentoken für das angegebene Element ab, falls verfügbar.
GetRuntimeBaseDefinition(MethodInfo)	Ruft ein Objekt ab, das die angegebene Methode für die direkte oder indirekte Basisklasse darstellt, in der die Methode zuerst deklariert wurde.
HasMetadataToken(MemberInfo)	Gibt einen Wert zurück, der angibt, ob ein Metadatentoken für das angegebene Element verfügbar ist.
IsDefined(MemberInfo, Type, Boolean)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf ein angegebenes Element angewendet werden und optional auf seine Vorgänger angewendet werden.
IsDefined(MemberInfo, Type)	Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf ein angegebenes Element angewendet werden.

Gilt für:

Feedback

War diese Seite hilfreich?