MethodBuilder Klasse

Definition

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 sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder
public ref class MethodBuilder abstract : 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
public abstract class MethodBuilder : System.Reflection.MethodInfo
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 NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
Public MustInherit Class MethodBuilder
Inherits MethodInfo
Vererbung
Attribute
Implementiert

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

Die MethodBuilder -Klasse wird verwendet, um eine Methode in MSIL (Microsoft Intermediate Language) vollständig zu beschreiben, einschließlich Name, Attribute, Signatur und Methodentext. Sie wird zusammen mit der TypeBuilder -Klasse verwendet, um Klassen zur Laufzeit zu erstellen.

Globale Methoden und Methoden als Typmember

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

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 Korrigieren des dynamischen Moduls verschiebt, bis alle globalen Funktionen definiert wurden.

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

Methoden als Member von Typen

Eine Methode wird als Typmember definiert, indem die -Methode verwendet TypeBuilder.DefineMethod wird, die ein MethodBuilder -Objekt zurückgibt.

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 zum Festlegen des Marshallings, zum Festlegen des konstanten Werts und zum Anwenden benutzerdefinierter Attribute verwendet werden.

Attribute

Member der MethodAttributes -Enumeration definieren das genaue Zeichen einer dynamischen Methode:

Bekannte Probleme

Konstruktoren

MethodBuilder()

Eigenschaften

Attributes

Ruft die Attribute für diese Methode ab.

CallingConvention

Gibt die Aufrufkonvention der Methode zurück.

CallingConvention

Ruft einen Wert ab, der die Aufrufkonventionen für diese Methode angibt.

(Geerbt von MethodBase)
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.

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
IsConstructedGenericMethod (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
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 Delegaten 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.

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.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dieser Instanz ist.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

(Geerbt von MethodInfo)
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.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

(Geerbt von MethodInfo)
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.

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) (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.

SetImplementationFlags(MethodImplAttributes)

Legt die Implementierungsflags für diese Methode fest.

SetMarshal(UnmanagedMarshal)
Veraltet.
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.

SetSymCustomAttribute(String, Byte[])

Legen Sie ein symbolisches benutzerdefiniertes Attribut mithilfe eines BLOBs fest.

ToString()

Gibt diese MethodBuilder-Instanz als Zeichenfolge zurück.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

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)
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: