DynamicMethod Klas

Definitie

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

Overname

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Kenmerken

ComVisibleAttribute

Voorbeelden

In het volgende codevoorbeeld wordt een dynamische methode gemaakt die twee parameters gebruikt. In het voorbeeld wordt een eenvoudige functietekst verzonden waarmee de eerste parameter naar de console wordt afgedrukt. In het voorbeeld wordt de tweede parameter gebruikt als de retourwaarde van de methode. In het voorbeeld wordt de methode voltooid door een gemachtigde te maken, de gemachtigde aan te roepen met verschillende parameters en ten slotte de dynamische methode aan te roepen met behulp van de Invoke methode.

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

Opmerkingen

U kunt de DynamicMethod klasse gebruiken om tijdens runtime een methode te genereren en uit te voeren, zonder dat u een dynamische assembly en een dynamisch type hoeft te genereren om de methode te bevatten. De uitvoerbare code die is gemaakt door de Just-In-Time-compiler (JIT) wordt vrijgemaakt wanneer het DynamicMethod object wordt vrijgemaakt. Dynamische methoden zijn de meest efficiënte manier om kleine hoeveelheden code te genereren en uit te voeren.

Een dynamische methode kan anoniem worden gehost of kan logisch worden gekoppeld aan een module of met een type.

• Als de dynamische methode anoniem wordt gehost, bevindt deze zich in een door het systeem geleverde assembly en is deze daarom geïsoleerd van andere code. Standaard heeft het geen toegang tot niet-openbare gegevens. Een anoniem gehoste dynamische methode kan een beperkte mogelijkheid hebben om de zichtbaarheidscontroles van de JIT-compiler over te slaan, als deze is verleend ReflectionPermission met de ReflectionPermissionFlag.RestrictedMemberAccess vlag. Het vertrouwensniveau van de assembly waarvan niet-openbare leden worden geopend door de dynamische methode, moet gelijk zijn aan, of een subset zijn van, het vertrouwensniveau van de aanroepstack die de dynamische methode heeft gegenereerd. Zie Walkthrough: Code verzenden in gedeeltelijke vertrouwensscenario's voor meer informatie over anoniem gehoste dynamische methoden.

• Als de dynamische methode is gekoppeld aan een module die u opgeeft, is de dynamische methode effectief globaal voor die module. Het heeft toegang tot alle typen in de module en alle internal (Friend in Visual Basic) leden van de typen. U kunt een dynamische methode koppelen aan elke module, ongeacht of u de module hebt gemaakt, mits aan een vraag ReflectionPermission naar de RestrictedMemberAccess vlag kan worden voldaan door de aanroepstack die uw code bevat. Als de ReflectionPermissionFlag.MemberAccess vlag is opgenomen in de toekenning, kan de dynamische methode de zichtbaarheidscontroles van de JIT-compiler overslaan en toegang krijgen tot de persoonlijke gegevens van alle typen die zijn gedeclareerd in de module of in een andere module in een assembly.

  Note

  Wanneer u de module opgeeft waaraan een dynamische methode is gekoppeld, mag die module zich niet in de door het systeem geleverde assembly bevinden die wordt gebruikt voor anonieme hosting.

• Als de dynamische methode is gekoppeld aan een type dat u opgeeft, heeft deze toegang tot alle leden van het type, ongeacht het toegangsniveau. Daarnaast kunnen JIT-zichtbaarheidscontroles worden overgeslagen. Dit geeft de dynamische methode toegang tot de privégegevens van andere typen die zijn gedeclareerd in dezelfde module of in een andere module in een assembly. U kunt een dynamische methode koppelen aan elk type, maar uw code moet ReflectionPermission worden verleend met zowel de RestrictedMemberAccess als MemberAccess vlaggen.

In de volgende tabel ziet u welke typen en leden toegankelijk zijn voor een anoniem gehoste dynamische methode, met en zonder JIT-zichtbaarheidscontroles, afhankelijk van of ReflectionPermission aan de RestrictedMemberAccess vlag wordt verleend.

In de volgende tabel ziet u welke typen en leden toegankelijk zijn voor een dynamische methode die is gekoppeld aan een module of met een type in een module.

Een dynamische methode die aan een module is gekoppeld, heeft de machtigingen van die module. Een dynamische methode die aan een type is gekoppeld, heeft de machtigingen van de module die dat type bevat.

Dynamische methoden en hun parameters hoeven niet benoemd te worden, maar u kunt namen opgeven om te helpen bij het opsporen van fouten. Aangepaste kenmerken worden niet ondersteund voor dynamische methoden of hun parameters.

Hoewel dynamische methoden staticmethoden (Sharedmethoden in Visual Basic) zijn, kunnen met de soepele regels voor gedelegeerde binding een dynamische methode aan een object worden gebonden, zodat deze fungeert als een instantiemethode wanneer deze wordt aangeroepen met behulp van die gedelegeerde instantie. Een voorbeeld dat dit laat zien, is beschikbaar voor de overbelasting van de CreateDelegate(Type, Object) methode.

Verification

De volgende lijst bevat een overzicht van de voorwaarden waaronder dynamische methoden niet-verifieerbare code kunnen bevatten. (Een dynamische methode kan bijvoorbeeld niet worden geverifieerd als de InitLocals eigenschap is ingesteld op false.)

• Een dynamische methode die is gekoppeld aan een beveiligingskritieke assembly is ook beveiligingskritiek en kan verificatie overslaan. Een assembly zonder beveiligingskenmerken die als een bureaubladtoepassing wordt uitgevoerd, wordt door de runtime als beveiligingskritiek beschouwd. Als u een dynamische methode aan de assembly koppelt, kan de dynamische methode niet-verifieerbare code bevatten.
• Als een dynamische methode die niet-verifieerbare code bevat, is gekoppeld aan een assembly met transparantie op niveau 1, injecteert de Just-In-Time-compiler een beveiligingsvraag. De vraag slaagt alleen als de dynamische methode wordt uitgevoerd door volledig vertrouwde code. Zie Security-Transparent Code, Niveau 1.
• Als een dynamische methode die niet-verifieerbare code bevat, is gekoppeld aan een assembly met transparantie op niveau 2 (zoals mscorlib.dll), wordt er een uitzondering gegenereerd (geïnjecteerd door de JIT-compiler) in plaats van een beveiligingsvraag te maken. Zie Security-Transparent Code, Niveau 2.
• Een anoniem gehoste dynamische methode die niet-verifieerbare code bevat, genereert altijd een uitzondering. De verificatie kan nooit worden overgeslagen, zelfs als deze wordt gemaakt en uitgevoerd door volledig vertrouwde code.

De uitzondering die wordt gegenereerd voor niet-verifieerbare code, is afhankelijk van de manier waarop de dynamische methode wordt aangeroepen. Als u een dynamische methode aanroept met behulp van een gemachtigde die is geretourneerd uit de CreateDelegate methode, wordt er een VerificationException gegenereerd. Als u de dynamische methode aanroept met behulp van de Invoke methode, wordt er een TargetInvocationException gegenereerd met een binnenste VerificationException.

Zie ook

• Procedure: Dynamische methoden definiëren en uitvoeren
• Beveiligingsproblemen in reflectie-emit
• Overzicht: Code verzenden in gedeeltelijke vertrouwensscenario's