DynamicMethod Klasse

Definition

Definiert eine dynamische Methode, die kompiliert, ausgeführt und verworfen werden kann, und stellt diese dar. Verworfene Methoden sind für die Garbage Collection verfügbar.

public ref class DynamicMethod sealed : System::Reflection::MethodInfo
public sealed class DynamicMethod : System.Reflection.MethodInfo
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo
type DynamicMethod = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ComVisible(true)>]
type DynamicMethod = class
    inherit MethodInfo
Public NotInheritable Class DynamicMethod
Inherits MethodInfo
Vererbung
Attribute

Beispiele

Im folgenden Codebeispiel wird eine dynamische Methode erstellt, die zwei Parameter verwendet. Im Beispiel wird ein einfacher Funktionstext ausgegeben, der den ersten Parameter in der Konsole druckt, und das Beispiel verwendet den zweiten Parameter als Rückgabewert der Methode. Im Beispiel wird die Methode durch Erstellen einer Stellvertretung abgeschlossen, die Stellvertretung mit verschiedenen Parametern aufgerufen und schließlich die dynamische Methode mithilfe der Invoke Methode aufgerufen.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Globalization;

// Declare a delegate type that can be used to execute the completed
// dynamic method. 
private delegate int HelloDelegate(String^ msg, int ret);

void main()
{
    // Create an array that specifies the types of the parameters
    // of the dynamic method. This dynamic method has a String
    // parameter and an Integer parameter.
    array<Type^>^ helloArgs = { String::typeid, int::typeid };

    // Create a dynamic method with the name "Hello", a return type
    // of Integer, and two parameters whose types are specified by
    // the array helloArgs. Create the method in the module that
    // defines the String class.
    DynamicMethod^ hello = gcnew DynamicMethod("Hello", 
        int::typeid, 
        helloArgs, 
        String::typeid->Module);

    // Create an array that specifies the parameter types of the
    // overload of Console::WriteLine to be used in Hello.
    array<Type^>^ writeStringArgs = { String::typeid };
    // Get the overload of Console::WriteLine that has one
    // String parameter.
    MethodInfo^ writeString = Console::typeid->GetMethod("WriteLine", 
        writeStringArgs);

    // Get an ILGenerator and emit a body for the dynamic method,
    // using a stream size larger than the IL that will be
    // emitted.
    ILGenerator^ il = hello->GetILGenerator(256);
    // Load the first argument, which is a string, onto the stack.
    il->Emit(OpCodes::Ldarg_0);
    // Call the overload of Console::WriteLine that prints a string.
    il->EmitCall(OpCodes::Call, writeString, nullptr);
    // The Hello method returns the value of the second argument;
    // to do this, load the onto the stack and return.
    il->Emit(OpCodes::Ldarg_1);
    il->Emit(OpCodes::Ret);

    // Add parameter information to the dynamic method. (This is not
    // necessary, but can be useful for debugging.) For each parameter,
    // identified by position, supply the parameter attributes and a 
    // parameter name.
    hello->DefineParameter(1, ParameterAttributes::In, "message");
    hello->DefineParameter(2, ParameterAttributes::In, "valueToReturn");

    // Create a delegate that represents the dynamic method. This
    // action completes the method. Any further attempts to
    // change the method are ignored.
    HelloDelegate^ hi = 
        (HelloDelegate^) hello->CreateDelegate(HelloDelegate::typeid);

    // Use the delegate to execute the dynamic method.
    Console::WriteLine("\r\nUse the delegate to execute the dynamic method:");
    int retval = hi("\r\nHello, World!", 42);
    Console::WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

    // Execute it again, with different arguments.
    retval = hi("\r\nHi, Mom!", 5280);
    Console::WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

    Console::WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
    // Create an array of arguments to use with the Invoke method.
    array<Object^>^ invokeArgs = { "\r\nHello, World!", 42 };
    // Invoke the dynamic method using the arguments. This is much
    // slower than using the delegate, because you must create an
    // array to contain the arguments, and value-type arguments
    // must be boxed.
    Object^ objRet = hello->Invoke(nullptr, BindingFlags::ExactBinding, nullptr, invokeArgs, gcnew CultureInfo("en-us"));
    Console::WriteLine("hello.Invoke returned: " + objRet);

    Console::WriteLine("\r\n ----- Display information about the dynamic method -----");
    // Display MethodAttributes for the dynamic method, set when 
    // the dynamic method was created.
    Console::WriteLine("\r\nMethod Attributes: {0}", hello->Attributes);

    // Display the calling convention of the dynamic method, set when the 
    // dynamic method was created.
    Console::WriteLine("\r\nCalling convention: {0}", hello->CallingConvention);

    // Display the declaring type, which is always null for dynamic
    // methods.
    if (hello->DeclaringType == nullptr)
    {
        Console::WriteLine("\r\nDeclaringType is always null for dynamic methods.");
    }
    else
    {
        Console::WriteLine("DeclaringType: {0}", hello->DeclaringType);
    }

    // Display the default value for InitLocals.
    if (hello->InitLocals)
    {
        Console::Write("\r\nThis method contains verifiable code.");
    }
    else
    {
        Console::Write("\r\nThis method contains unverifiable code.");
    }
    Console::WriteLine(" (InitLocals = {0})", hello->InitLocals);

    // Display the module specified when the dynamic method was created.
    Console::WriteLine("\r\nModule: {0}", hello->Module);

    // Display the name specified when the dynamic method was created.
    // Note that the name can be blank.
    Console::WriteLine("\r\nName: {0}", hello->Name);

    // For dynamic methods, the reflected type is always null.
    if (hello->ReflectedType == nullptr)
    {
        Console::WriteLine("\r\nReflectedType is null.");
    }
    else
    {
        Console::WriteLine("\r\nReflectedType: {0}", hello->ReflectedType);
    }

    if (hello->ReturnParameter == nullptr)
    {
        Console::WriteLine("\r\nMethod has no return parameter.");
    }
    else
    {
        Console::WriteLine("\r\nReturn parameter: {0}", hello->ReturnParameter);
    }

    // If the method has no return type, ReturnType is System.Void.
    Console::WriteLine("\r\nReturn type: {0}", hello->ReturnType);

    // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
    // that can be used to enumerate the custom attributes of the
    // return value. At present, there is no way to set such custom
    // attributes, so the list is empty.
    if (hello->ReturnType == Void::typeid)
    {
        Console::WriteLine("The method has no return type.");
    }
    else
    {
        ICustomAttributeProvider^ caProvider = hello->ReturnTypeCustomAttributes;
        array<Object^>^ returnAttributes = caProvider->GetCustomAttributes(true);
        if (returnAttributes->Length == 0)
        {
            Console::WriteLine("\r\nThe return type has no custom attributes.");
        }
        else
        {
            Console::WriteLine("\r\nThe return type has the following custom attributes:");
            for each (Object^ attr in returnAttributes)
            {
                Console::WriteLine("\t{0}", attr->ToString());
            }
        }
    }

    Console::WriteLine("\r\nToString: {0}", hello->ToString());

    // Display parameter information.
    array<ParameterInfo^>^ parameters = hello->GetParameters();
    Console::WriteLine("\r\nParameters: name, type, ParameterAttributes");
    for each (ParameterInfo^ p in parameters)
    {
        Console::WriteLine("\t{0}, {1}, {2}", 
            p->Name, p->ParameterType, p->Attributes);
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method.
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello",
            typeof(int),
            helloArgs,
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine",
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi =
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and value-type arguments
        // must be boxed.
        object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
        Console.WriteLine("hello.Invoke returned: " + objRet);

        Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}",
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Globalization

Public Class Test
    ' Declare a delegate type that can be used to execute the completed
    ' dynamic method. 
    Private Delegate Function HelloDelegate(ByVal msg As String, _
        ByVal ret As Integer) As Integer

    Public Shared Sub Main()
        ' Create an array that specifies the types of the parameters
        ' of the dynamic method. This dynamic method has a String
        ' parameter and an Integer parameter.
        Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

        ' Create a dynamic method with the name "Hello", a return type
        ' of Integer, and two parameters whose types are specified by
        ' the array helloArgs. Create the method in the module that
        ' defines the String class.
        Dim hello As New DynamicMethod("Hello", _
            GetType(Integer), _
            helloArgs, _
            GetType(String).Module)

        ' Create an array that specifies the parameter types of the
        ' overload of Console.WriteLine to be used in Hello.
        Dim writeStringArgs() As Type = {GetType(String)}
        ' Get the overload of Console.WriteLine that has one
        ' String parameter.
        Dim writeString As MethodInfo = GetType(Console). _
            GetMethod("WriteLine", writeStringArgs) 

        ' Get an ILGenerator and emit a body for the dynamic method,
        ' using a stream size larger than the IL that will be
        ' emitted.
        Dim il As ILGenerator = hello.GetILGenerator(256)
        ' Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0)
        ' Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, Nothing)
        ' The Hello method returns the value of the second argument;
        ' to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1)
        il.Emit(OpCodes.Ret)

        ' Add parameter information to the dynamic method. (This is not
        ' necessary, but can be useful for debugging.) For each parameter,
        ' identified by position, supply the parameter attributes and a 
        ' parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message")
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn")

        ' Create a delegate that represents the dynamic method. This
        ' action completes the method. Any further attempts to
        ' change the method are ignored.
    Dim hi As HelloDelegate = _
            CType(hello.CreateDelegate(GetType(HelloDelegate)), HelloDelegate)

        ' Use the delegate to execute the dynamic method.
        Console.WriteLine(vbCrLf & "Use the delegate to execute the dynamic method:")
        Dim retval As Integer = hi(vbCrLf & "Hello, World!", 42)
        Console.WriteLine("Invoking delegate hi(""Hello, World!"", 42) returned: " _
            & retval & ".")

        ' Execute it again, with different arguments.
        retval = hi(vbCrLf & "Hi, Mom!", 5280)
        Console.WriteLine("Invoking delegate hi(""Hi, Mom!"", 5280) returned: " _
            & retval & ".")

        Console.WriteLine(vbCrLf & "Use the Invoke method to execute the dynamic method:")
        ' Create an array of arguments to use with the Invoke method.
        Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
        ' Invoke the dynamic method using the arguments. This is much
        ' slower than using the delegate, because you must create an
        ' array to contain the arguments, and value-type arguments
        ' must be boxed.
        Dim objRet As Object = hello.Invoke(Nothing, _
            BindingFlags.ExactBinding, Nothing, invokeArgs, _
            New CultureInfo("en-us"))
        Console.WriteLine("hello.Invoke returned: {0}", objRet)

        Console.WriteLine(vbCrLf & _
            " ----- Display information about the dynamic method -----")
        ' Display MethodAttributes for the dynamic method, set when 
        ' the dynamic method was created.
        Console.WriteLine(vbCrLf & "Method Attributes: {0}", _
            hello.Attributes)

        ' Display the calling convention of the dynamic method, set when the 
        ' dynamic method was created.
        Console.WriteLine(vbCrLf & "Calling convention: {0}", _ 
            hello.CallingConvention)

        ' Display the declaring type, which is always Nothing for dynamic
        ' methods.
        If hello.DeclaringType Is Nothing Then
            Console.WriteLine(vbCrLf & "DeclaringType is always Nothing for dynamic methods.")
        Else
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType)
        End If

        ' Display the default value for InitLocals.
        If hello.InitLocals Then
            Console.Write(vbCrLf & "This method contains verifiable code.")
        Else
            Console.Write(vbCrLf & "This method contains unverifiable code.")
        End If
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals)

        ' Display the module specified when the dynamic method was created.
        Console.WriteLine(vbCrLf & "Module: {0}", hello.Module)

        ' Display the name specified when the dynamic method was created.
        ' Note that the name can be blank.
        Console.WriteLine(vbCrLf & "Name: {0}", hello.Name)

        ' For dynamic methods, the reflected type is always Nothing.
        If hello.ReflectedType Is Nothing Then
            Console.WriteLine(vbCrLf & "ReflectedType is Nothing.")
        Else
            Console.WriteLine(vbCrLf & "ReflectedType: {0}", _
                hello.ReflectedType)
        End If

        If hello.ReturnParameter Is Nothing Then
            Console.WriteLine(vbCrLf & "Method has no return parameter.")
        Else
            Console.WriteLine(vbCrLf & "Return parameter: {0}", _
                hello.ReturnParameter)
        End If

        ' If the method has no return type, ReturnType is System.Void.
        Console.WriteLine(vbCrLf & "Return type: {0}", hello.ReturnType)           

        ' ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        ' that can be used to enumerate the custom attributes of the
        ' return value. At present, there is no way to set such custom
        ' attributes, so the list is empty.
        If hello.ReturnType Is GetType(System.Void) Then
            Console.WriteLine("The method has no return type.")
        Else
            Dim caProvider As ICustomAttributeProvider = _
                hello.ReturnTypeCustomAttributes
            Dim returnAttributes() As Object = _
                caProvider.GetCustomAttributes(True)
            If returnAttributes.Length = 0 Then
                Console.WriteLine(vbCrLf _
                    & "The return type has no custom attributes.")
            Else
                Console.WriteLine(vbCrLf _
                    & "The return type has the following custom attributes:")
                For Each attr As Object In returnAttributes
                    Console.WriteLine(vbTab & attr.ToString())
                Next attr
            End If
        End If

        Console.WriteLine(vbCrLf & "ToString: " & hello.ToString())

        ' Display parameter information.
        Dim parameters() As ParameterInfo = hello.GetParameters()
        Console.WriteLine(vbCrLf & "Parameters: name, type, ParameterAttributes")
        For Each p As ParameterInfo In parameters
            Console.WriteLine(vbTab & "{0}, {1}, {2}", _ 
                p.Name, p.ParameterType, p.Attributes)
        Next p
    End Sub
End Class

' This code example produces the following output:
'
'Use the delegate to execute the dynamic method:
'
'Hello, World!
'Invoking delegate hi("Hello, World!", 42) returned: 42.
'
'Hi, Mom!
'Invoking delegate hi("Hi, Mom!", 5280) returned: 5280.
'
'Use the Invoke method to execute the dynamic method:
'
'Hello, World!
'hello.Invoke returned: 42
'
' ----- Display information about the dynamic method -----
'
'Method Attributes: PrivateScope, Public, Static
'
'Calling convention: Standard
'
'DeclaringType is always Nothing for dynamic methods.
'
'This method contains verifiable code. (InitLocals = True)
'
'Module: CommonLanguageRuntimeLibrary
'
'Name: Hello
'
'ReflectedType is Nothing.
'
'Method has no return parameter.
'
'Return type: System.Int32
'
'The return type has no custom attributes.
'
'ToString: Int32 Hello(System.String, Int32)
'
'Parameters: name, type, ParameterAttributes
'        message, System.String, In
'        valueToReturn, System.Int32, In

Hinweise

Sie können die DynamicMethod Klasse verwenden, um eine Methode zur Laufzeit zu generieren und auszuführen, ohne eine dynamische Assembly und einen dynamischen Typ zur Verwendung der Methode zu generieren und auszuführen. Der vom JIT-Compiler (Just-in-Time) erstellte ausführbare Code wird beim erneuten Abrufen des DynamicMethod Objekts zurückgegeben. Dynamische Methoden sind die effizienteste Möglichkeit, kleine Codemengen zu generieren und auszuführen.

Eine dynamische Methode kann anonym gehostet werden, oder sie kann logisch einem Modul oder einem Typ zugeordnet werden.

  • Wenn die dynamische Methode anonym gehostet wird, befindet sie sich in einer vom System bereitgestellten Assembly und ist daher von anderen Code isoliert. Standardmäßig verfügt sie nicht über Zugriff auf nicht öffentliche Daten. Eine anonym gehostete dynamische Methode kann die Möglichkeit haben, die Sichtbarkeitsprüfungen des JIT-Compilers zu überspringen, wenn sie mit dem ReflectionPermissionFlag.RestrictedMemberAccess Flag erteilt ReflectionPermission wurde. Die Vertrauensstufe der Assembly, auf die nicht öffentliche Mitglieder von der dynamischen Methode zugegriffen werden, muss gleich der Vertrauensstufe des Aufrufstapels sein, der die dynamische Methode ausgibt. Weitere Informationen zu anonym gehosteten dynamischen Methoden finden Sie unter Walkthrough: Emitting Code in Partial Trust Scenarios.

  • Wenn die dynamische Methode einem von Ihnen angegebenen Modul zugeordnet ist, ist die dynamische Methode effektiv global für dieses Modul. Er kann auf alle Typen im Modul und alle internal (Friend in Visual Basic) Member der Typen zugreifen. Sie können eine dynamische Methode jedem Modul zuordnen, unabhängig davon, ob Sie das Modul erstellt haben, vorausgesetzt, dass eine Nachfrage nach ReflectionPermission dem RestrictedMemberAccess Flag durch den Aufrufstapel, der Ihren Code enthält, erfüllt werden kann. Wenn das Kennzeichen in der Erteilung enthalten ist, kann die ReflectionPermissionFlag.MemberAccess dynamische Methode die Sichtbarkeitsprüfungen des JIT-Compilers überspringen und auf die privaten Daten aller Typen zugreifen, die im Modul oder in einem anderen Modul in einer beliebigen Assembly deklariert sind.

    Hinweis

    Wenn Sie das Modul angeben, dem eine dynamische Methode zugeordnet ist, darf sich dieses Modul nicht in der vom System bereitgestellten Assembly befinden, die für anonymes Hosting verwendet wird.

  • Wenn die dynamische Methode einem von Ihnen angegebenen Typ zugeordnet ist, hat sie Zugriff auf alle Member des Typs, unabhängig von der Zugriffsstufe. Darüber hinaus können JIT-Sichtbarkeitsprüfungen übersprungen werden. Dadurch erhält die dynamische Methode Zugriff auf die privaten Daten anderer Typen, die in demselben Modul oder in einem anderen Modul in jeder Assembly deklariert sind. Sie können eine dynamische Methode einem beliebigen Typ zuordnen, aber Ihr Code muss sowohl mit den als MemberAccess auch mit den RestrictedMemberAccess Flags gewährt ReflectionPermission werden.

In der folgenden Tabelle wird gezeigt, welche Typen und Member für eine anonym gehostete dynamische Methode mit und ohne JIT-Sichtbarkeitsprüfungen zugänglich sind, je nachdem, ob ReflectionPermission die RestrictedMemberAccess Kennzeichnung erteilt wird.

Ohne RestrictedMemberAccess Mit RestrictedMemberAccess
Ohne JIT-Sichtbarkeitsprüfungen zu überspringen Öffentliche Mitglieder öffentlicher Typen in jeder Assembly. Öffentliche Mitglieder öffentlicher Typen in jeder Assembly.
Überspringen von JIT-Sichtbarkeitsprüfungen mit Einschränkungen Öffentliche Mitglieder öffentlicher Typen in jeder Assembly. Alle Member aller Typen, nur in Assemblys, deren Vertrauensstufen gleich oder kleiner sind als die Vertrauensstufe der Assembly, die die dynamische Methode ausgibt.

Hinweis

.NET Framework 2.0 ermöglicht es Code, in teilweise vertrauenswürdigen Szenarien ohne Sicherheitsanforderungen auszugeben, da das Generieren von Code kein privilegierter Vorgang ist. Das bedeutet, dass der generierte Code nicht mehr Berechtigungen aufweist als die Assembly, die ihn ausgibt. Dies ermöglicht es, dass Bibliotheken, die Code ausgeben, sicherheitstransparent sein können, und beseitigt die Notwendigkeit der Assertion von ReflectionEmit, was das Schreiben einer sicheren Bibliothek vereinfacht. Um dieses Feature zu verwenden, sollte Ihre Anwendung auf .NET Framework 3.5 oder höher abzielen.

In der folgenden Tabelle wird gezeigt, auf welche Typen und Member auf eine dynamische Methode zugegriffen werden kann, die einem Modul oder einem Typ in einem Modul zugeordnet ist.

Zugeordnet mit Modul Dem Typ zugeordnet
Ohne JIT-Sichtbarkeitsprüfungen zu überspringen Öffentliche und interne Mitglieder öffentlicher, interner und privater Typen im Modul.

Öffentliche Mitglieder öffentlicher Typen in jeder Assembly.
Alle Member des zugeordneten Typs. Öffentliche und interne Member aller anderen Typen im Modul.

Öffentliche Mitglieder öffentlicher Typen in jeder Assembly.
Überspringen von JIT-Sichtbarkeitsprüfungen Alle Member aller Typen in jeder Assembly. Alle Member aller Typen in jeder Assembly.

Eine dynamische Methode, die einem Modul zugeordnet ist, verfügt über die Berechtigungen dieses Moduls. Eine dynamische Methode, die einem Typ zugeordnet ist, verfügt über die Berechtigungen des Moduls, das diesen Typ enthält.

Dynamische Methoden und deren Parameter müssen nicht benannt werden, aber Sie können Namen angeben, die beim Debuggen unterstützt werden sollen. Benutzerdefinierte Attribute werden für dynamische Methoden oder deren Parameter nicht unterstützt.

Obwohl dynamische Methoden (Shared Methoden in Visual Basic) sindstatic, können die in der .NET Framework 2.0 eingeführten entspannten Regeln für die Stellvertretungsbindung eine dynamische Methode an ein Objekt gebunden werden, sodass sie wie eine Instanzmethode fungiert, wenn diese Delegateninstanz verwendet wird. Ein Beispiel, das dies veranschaulicht, wird für die CreateDelegate(Type, Object) Methodenüberladung bereitgestellt.

Hinweis

In den .NET Framework 2.0 unterstützen dynamische Methoden keine Symbolinformationen, d. h. lokale Variablennamen und Zeilennummernzuordnung. Diese Einschränkung kann in einer zukünftigen Version entfernt werden. Sie können während der Entwicklung verwenden AssemblyBuilder , um das Debuggen der generierten Microsoft-Zwischensprache (MSIL) zu vereinfachen und dann während der endgültigen Bereitstellung zu dynamischen Methoden zu wechseln, da die ILGenerator Aufrufe in beiden Fällen identisch sind.

Überprüfung

In der folgenden Liste werden die Bedingungen zusammengefasst, unter denen dynamische Methoden unifizierbaren Code enthalten können. (Beispielsweise ist eine dynamische Methode unverifizierbar, wenn die InitLocals Eigenschaft auf false.)

  • Eine dynamische Methode, die einer sicherheitskritischen Assembly zugeordnet ist, ist auch sicherheitskritisch und kann die Überprüfung überspringen. Beispielsweise wird eine Assembly ohne Sicherheitsattribute, die als Desktopanwendung ausgeführt werden, von der Laufzeit als sicherheitskritischer Vorgang behandelt. Wenn Sie der Assembly eine dynamische Methode zuordnen, kann die dynamische Methode unifizierbaren Code enthalten.

  • Wenn eine dynamische Methode, die unverifizierbarem Code enthält, einer Assembly zugeordnet ist, die Transparenz der Ebene 1 aufweist, fügt der JIT-Compiler eine Sicherheitsnachfrage ein. Die Anforderung ist nur erfolgreich, wenn die dynamische Methode durch vollständig vertrauenswürdigen Code ausgeführt wird. Sicherheitstransparenter Code, Ebene 1.

  • Wenn eine dynamische Methode, die unverifizierbarem Code enthält, einer Assembly zugeordnet ist, die Level 2 Transparenz aufweist (z. B. mscorlib.dll), löst sie eine Ausnahme (injiziert vom JIT-Compiler) aus, anstatt eine Sicherheitsnachfrage zu machen. Sicherheitstransparenter Code, Ebene 2.

  • Eine anonym gehostete dynamische Methode, die unverifizierbarem Code enthält, löst immer eine Ausnahme aus. Die Überprüfung kann niemals übersprungen werden, auch wenn sie durch vollständig vertrauenswürdigen Code erstellt und ausgeführt wird.

Die Ausnahme, die für nichtifizierbaren Code ausgelöst wird, variiert je nachdem, wie die dynamische Methode aufgerufen wird. Wenn Sie eine dynamische Methode mithilfe einer von der CreateDelegate Methode zurückgegebenen Stellvertretung aufrufen, wird eine VerificationException ausgelöst. Wenn Sie die dynamische Methode mithilfe der Invoke Methode aufrufen, wird eine TargetInvocationException mit einem inneren VerificationExceptionAusgelöst.

Konstruktoren

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und Methodennamen, Attribute, die Aufrufkonvention, den Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

Erstellt eine dynamische Methode. Dabei werden der Methodenname, die Attribute, die Aufrufkonvention, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.

DynamicMethod(String, Type, Type[])

Initialisiert eine anonym gehostete dynamische Methode, wobei der Methodenname, der Rückgabetyp und die Parametertypen angegeben werden.

DynamicMethod(String, Type, Type[], Boolean)

Initialisiert eine anonym gehostete dynamische Methode. Dazu werden der Methodenname, der Rückgabetyp und die Parametertypen angegeben und wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

DynamicMethod(String, Type, Type[], Module)

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, den Rückgabetyp, die Parametertypen und das Modul angibt.

DynamicMethod(String, Type, Type[], Module, Boolean)

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

DynamicMethod(String, Type, Type[], Type)

Erstellt eine dynamische Methode und gibt den Methodennamen, den Rückgabetyp, die Parametertypen und den Typ an, dem die dynamische Methode logisch zugeordnet ist.

DynamicMethod(String, Type, Type[], Type, Boolean)

Erstellt eine dynamische Methode. Dabei werden der Methodenname, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.

Eigenschaften

Attributes

Ruft die Attribute ab, die beim Erstellen der dynamischen Methode angegeben wurden.

CallingConvention

Ruft die Aufrufkonvention ab, die beim Erstellen der dynamischen Methode angegeben wurde.

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

Ruft den Typ ab, der die Methode deklariert und für dynamische Methoden immer null ist.

InitLocals

Ruft einen Wert ab, der angibt, ob die lokalen Variablen in der Methode mit 0 (null) initialisiert werden, oder legt diesen Wert fest.

IsAbstract

Ruft einen Wert ab, der angibt, ob es sich um eine abstrakte Methode handelt.

(Geerbt von MethodBase)
IsAssembly

Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode bzw. dieses Konstruktors von Assembly beschrieben wird, d. h., die Methode oder der Konstruktor ist höchstens für andere Typen in derselben Assembly sichtbar, nicht jedoch für abgeleitete Typen außerhalb der Assembly.

(Geerbt von MethodBase)
IsCollectible

Ruft einen Wert ab, der angibt, ob dieses AssemblyLoadContext-Objekt Teil einer Assembly ist, die sich in einem entladbaren MemberInfo befindet.

(Geerbt von MemberInfo)
IsConstructedGenericMethod (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 aktuelle Methode eine generische Methode ist.

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

Ruft einen Wert ab, der angibt, ob die aktuelle dynamische Methode sicherheitsrelevant ist und daher wichtige Vorgänge ausführen darf.

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

Ruft einen Wert ab, der angibt, ob die aktuelle dynamische Methode auf der aktuellen Vertrauensebene sicherheitsgeschützt ist, d. h. ob sie wichtige Vorgänge ausführen darf und ob von transparentem Code auf sie zugegriffen werden kann.

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

Ruft einen Wert ab, der angibt, ob die aktuelle dynamische Methode auf der aktuellen Vertrauensebene sicherheitstransparent ist und daher keine wichtigen Vorgänge ausführen kann.

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 einen Wert ab, der ein Metadatenelement identifiziert.

(Geerbt von MemberInfo)
MethodHandle

Für dynamische Methoden nicht unterstützt.

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, dem die dynamische Methode logisch zugeordnet ist.

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 der dynamischen Methode ab.

ReflectedType

Ruft die Klasse ab, die bei der Reflektion zum Abrufen der Methode verwendet wurde.

ReflectedType

Ruft das Klassenobjekt ab, mit dem diese Instanz von MemberInfo abgerufen wurde.

(Geerbt von MemberInfo)
ReturnParameter

Ruft den Rückgabeparameter der dynamischen Methode ab.

ReturnType

Ruft den Typ des Rückgabewerts für die dynamische Methode ab.

ReturnTypeCustomAttributes

Ruft die benutzerdefinierten Attribute des Rückgabetyps für die dynamische Methode ab.

ReturnTypeCustomAttributes

Ruft die benutzerdefinierten Attribute für den Rückgabetyp ab.

(Geerbt von MethodInfo)

Methoden

CreateDelegate(Type)

Vervollständigt die dynamische Methode und erstellt einen Delegaten, mit dem die Methode ausgeführt werden kann.

CreateDelegate(Type, Object)

Vervollständigt die dynamische Methode und erstellt einen Delegaten, mit dem die Methode ausgeführt werden kann, wobei der Delegattyp und ein Objekt angegeben werden, das an den Delegaten gebunden ist.

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)
DefineParameter(Int32, ParameterAttributes, String)

Definiert einen Parameter der dynamischen Methode.

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 die 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 die 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 des angegebenen Typs zurück, die auf die Methode angewendet wurden.

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

Gibt ein DynamicILInfo-Objekt zurück, das zum Generieren von Methodentext aus Metadatentoken, Bereichen und MSIL-Streams (Microsoft Intermediate Language) verwendet werden kann.

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 ein MethodInfo-Objekt zurück, das eine generische Methodendefinition darstellt, aus der die aktuelle Methode konstruiert werden kann.

(Geerbt von MethodInfo)
GetHashCode()

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

(Geerbt von MethodInfo)
GetILGenerator()

Gibt für die Methode einen MSIL-Generator (Microsoft Intermediate Language) mit einer MSIL-Standardstreamgröße von 64 Byte zurück.

GetILGenerator(Int32)

Gibt für die Methode einen MSIL-Generator (Microsoft Intermediate Language) mit der angegebenen Größe der MSIL-Streams 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)
GetParameters()

Gibt die Parameter der dynamischen Methode zurück.

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 die dynamische Methode mithilfe des angegebenen Parameters und den Einschränkungen des angegebenen Binders mit den angegebenen Kulturinformationen auf.

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)

Gibt an, 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[])

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

Gibt die Signatur der Methode als Zeichenfolge zurück.

Explizite Schnittstellenimplementierungen

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von MemberInfo)
_MemberInfo.GetType()

Ruft ein Type-Objekt ab, das die MemberInfo-Klasse darstellt.

(Geerbt von MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

(Geerbt von MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von MethodBase)
_MethodBase.GetType()

Eine Beschreibung dieses Elements finden Sie unter GetType().

(Geerbt von MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

(Geerbt von MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von MethodBase)
_MethodBase.IsAbstract

Eine Beschreibung dieses Elements finden Sie unter IsAbstract.

(Geerbt von MethodBase)
_MethodBase.IsAssembly

Eine Beschreibung dieses Elements finden Sie unter IsAssembly.

(Geerbt von MethodBase)
_MethodBase.IsConstructor

Eine Beschreibung dieses Elements finden Sie unter IsConstructor.

(Geerbt von MethodBase)
_MethodBase.IsFamily

Eine Beschreibung dieses Elements finden Sie unter IsFamily.

(Geerbt von MethodBase)
_MethodBase.IsFamilyAndAssembly

Eine Beschreibung dieses Elements finden Sie unter IsFamilyAndAssembly.

(Geerbt von MethodBase)
_MethodBase.IsFamilyOrAssembly

Eine Beschreibung dieses Elements finden Sie unter IsFamilyOrAssembly.

(Geerbt von MethodBase)
_MethodBase.IsFinal

Eine Beschreibung dieses Elements finden Sie unter IsFinal.

(Geerbt von MethodBase)
_MethodBase.IsHideBySig

Eine Beschreibung dieses Elements finden Sie unter IsHideBySig.

(Geerbt von MethodBase)
_MethodBase.IsPrivate

Eine Beschreibung dieses Elements finden Sie unter IsPrivate.

(Geerbt von MethodBase)
_MethodBase.IsPublic

Eine Beschreibung dieses Elements finden Sie unter IsPublic.

(Geerbt von MethodBase)
_MethodBase.IsSpecialName

Eine Beschreibung dieses Elements finden Sie unter IsSpecialName.

(Geerbt von MethodBase)
_MethodBase.IsStatic

Eine Beschreibung dieses Elements finden Sie unter IsStatic.

(Geerbt von MethodBase)
_MethodBase.IsVirtual

Eine Beschreibung dieses Elements finden Sie unter IsVirtual.

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

Siehe auch