DynamicMethod Klasse

Definition

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

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Attribute

ComVisibleAttribute

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 im Beispiel wird der zweite Parameter als Rückgabewert der Methode verwendet. Im Beispiel wird die Methode abgeschlossen, indem sie einen Delegaten erstellt, den Delegaten mit verschiedenen Parametern aufruft und schließlich die dynamische Methode mithilfe der Invoke Methode aufruft.

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 generieren zu müssen, der die Methode enthalten soll. Der vom JIT-Compiler (Just-in-Time) erstellte ausführbare Code wird erneut beansprucht, wenn das DynamicMethod Objekt erneut beansprucht wird. Dynamische Methoden sind die effizienteste Methode zum Generieren und Ausführen kleiner Codemengen.

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 einem anderen Code isoliert. Standardmäßig hat sie keinen Zugriff auf nicht öffentliche Daten. Eine anonym gehostete dynamische Methode kann eingeschränkt die Sichtbarkeitsprüfungen des JIT-Compilers überspringen, wenn ihr mit dem Flag ReflectionPermission die Berechtigung ReflectionPermissionFlag.RestrictedMemberAccess erteilt wurde. Die Vertrauensstufe der Assembly, auf deren nicht-öffentliche Mitglieder die dynamische Methode zugreift, muss gleich oder eine Untermenge der Vertrauensstufe des Call-Stacks sein, von dem die dynamische Methode ausgeht. 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) Mitglieder der Typen zugreifen. Sie können eine dynamische Methode mit jedem Modul verknüpfen, unabhängig davon, ob Sie das Modul erstellt haben, vorausgesetzt, eine Anforderung für ReflectionPermission mit dem RestrictedMemberAccess-Flag kann vom Aufrufstapel erfüllt werden, der Ihren Code enthält. Wenn das ReflectionPermissionFlag.MemberAccess Flag in der Erteilung enthalten ist, kann die 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.

  Note

  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 unabhängig von der Zugriffsebene Zugriff auf alle Member des Typs. Darüber hinaus können JIT-Sichtbarkeitsprüfungen übersprungen werden. Dadurch erhält die dynamische Methode Zugriff auf die privaten Daten anderer Typen, die im selben Modul oder in einem anderen Modul in jeder Assembly deklariert sind. Sie können eine dynamische Methode mit jedem Typ verknüpfen, aber Ihr Code muss ReflectionPermission mit den beiden Flags RestrictedMemberAccess und MemberAccess versehen sein.

Die folgende Tabelle zeigt, auf welche Typen und Mitglieder eine anonym gehostete dynamische Methode mit und ohne JIT-Sichtbarkeitsprüfungen zugreifen kann, je nachdem, ob ReflectionPermission mit dem Flag RestrictedMemberAccess gewährt wird.

Die folgende Tabelle zeigt, auf welche Typen und Member für eine dynamische Methode zugegriffen werden kann, die einem Modul oder einem Typ in einem Modul zugeordnet ist.

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 ihre 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 static Methoden (Shared Methoden in Visual Basic) sind, erlauben die entspannten Regeln für die Delegatenbindung, dass eine dynamische Methode an ein Objekt gebunden wird, sodass sie wie eine Instanzmethode funktioniert, wenn sie über diese Delegateninstanz aufgerufen wird. Ein Beispiel, das dies veranschaulicht, ist die Überladung der Methode CreateDelegate(Type, Object).

Verifizierung

In der folgenden Liste sind die Bedingungen zusammengefasst, unter denen dynamische Methoden nicht ifizierbaren Code enthalten können. (Zum Beispiel ist eine dynamische Methode nicht verifizierbar, wenn ihre InitLocals-Eigenschaft auf false festgelegt ist.)

• Eine dynamische Methode, die einer sicherheitskritischen Assembly zugeordnet ist, ist ebenfalls sicherheitskritisch und kann die Überprüfung überspringen. Beispielsweise wird eine Assembly ohne Sicherheitsattribute, die als Desktopanwendung ausgeführt werden, von der Laufzeit als sicherheitskritisch behandelt. Wenn Sie der Assembly eine dynamische Methode zuordnen, kann die dynamische Methode unverifizierbaren Code enthalten.
• Wenn eine dynamische Methode, die unverifizierbaren 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 mit voll vertrauenswürdigen Code ausgeführt wird. Siehe Security-Transparent Code, Ebene 1.
• Wenn eine dynamische Methode, die unverifizierbaren Code enthält, einer Assembly mit Transparenz der Ebene 2 (z. B. mscorlib.dll) zugeordnet ist, löst sie eine Ausnahme (vom JIT-Compiler eingefügt) aus, anstatt eine Sicherheitsaufforderung vorzunehmen. Siehe Security-Transparent Code, Ebene 2.
• Eine anonym gehostete dynamische Methode, die unverifizierbarem Code enthält, löst immer eine Ausnahme aus. Sie kann die Überprüfung niemals überspringen, 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 nach Aufruf der dynamischen Methode. Wenn Sie eine dynamische Methode mit Hilfe eines Delegaten aufrufen, der von der CreateDelegate Methode ausgelöst wurde, wird ein VerificationException ausgelöst. Wenn Sie die dynamische Methode über die Methode Invoke aufrufen, wird ein TargetInvocationException mit einem inneren VerificationException ausgelöst.

Weitere Informationen

• Vorgehensweise: Definieren und Ausführen dynamischer Methoden
• Sicherheitsprobleme in Reflection Emit
• Exemplarische Vorgehensweise: Ausgebenden Code in Teilweisen Vertrauensszenarien