MethodBuilder Klasse

Definition

Namespace:: System.Reflection.Emit

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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 sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder

public ref class MethodBuilder sealed : 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

public sealed class MethodBuilder : System.Reflection.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

type MethodBuilder = class
    inherit MethodInfo

Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder

Public NotInheritable Class MethodBuilder
Inherits MethodInfo

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

Weitere Informationen zu dieser API finden Sie in den ergänzenden API-Hinweisen für MethodBuilder.

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`.
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)
IsConstructedGenericMethod	Definiert und stellt eine Methode (oder einen Konstruktor) für eine dynamische Klasse dar.
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 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	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 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.
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)
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.
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.
Equals(Object)	Bestimmt, ob das angegebene Objekt dieser Instanz entspricht.
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 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.
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.
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.
SetImplementationFlags(MethodImplAttributes)	Legt die Implementierungskennzeichnungen für diese Methode fest.
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.
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)

Erweiterungsmethoden

Name	Beschreibung
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.
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.
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?