DynamicMethod Classe

Définition

Définit et représente une méthode dynamique qui peut être compilée, exécutée et ignorée.Defines and represents a dynamic method that can be compiled, executed, and discarded. Les méthodes ignorées sont disponibles pour le garbage collection.Discarded methods are available for garbage collection.

public ref class DynamicMethod sealed : System::Reflection::MethodInfo
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo
type DynamicMethod = class
    inherit MethodInfo
Public NotInheritable Class DynamicMethod
Inherits MethodInfo
Héritage
Attributs

Exemples

L’exemple de code suivant crée une méthode dynamique qui accepte deux paramètres.The following code example creates a dynamic method that takes two parameters. L’exemple émet un corps de fonction simple qui imprime le premier paramètre de la console, et l’exemple utilise le deuxième paramètre comme valeur de retour de la méthode.The example emits a simple function body that prints the first parameter to the console, and the example uses the second parameter as the return value of the method. L’exemple termine la méthode en créant un délégué, appelle le délégué avec des paramètres différents, puis appelle la méthode dynamique à l’aide de Invoke la méthode.The example completes the method by creating a delegate, invokes the delegate with different parameters, and finally invokes the dynamic method using the Invoke method.

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

Remarques

Vous pouvez utiliser la DynamicMethod classe pour générer et exécuter une méthode au moment de l’exécution, sans avoir à générer un assembly dynamique et un type dynamique pour contenir la méthode.You can use the DynamicMethod class to generate and execute a method at run time, without having to generate a dynamic assembly and a dynamic type to contain the method. Le code exécutable créé par le compilateur juste-à-temps (JIT) est récupéré lorsque l' DynamicMethod objet est récupéré.The executable code created by the just-in-time (JIT) compiler is reclaimed when the DynamicMethod object is reclaimed. Les méthodes dynamiques sont le moyen le plus efficace de générer et d’exécuter de petites quantités de code.Dynamic methods are the most efficient way to generate and execute small amounts of code.

Une méthode dynamique peut être hébergée de manière anonyme, ou elle peut être associée logiquement à un module ou à un type.A dynamic method can be anonymously hosted, or it can be logically associated with a module or with a type.

  • Si la méthode dynamique est hébergée de façon anonyme, elle se trouve dans un assembly fourni par le système et est donc isolée d’un autre code.If the dynamic method is anonymously hosted, it is located in a system-provided assembly, and therefore is isolated from other code. Par défaut, il n’a accès à aucune donnée non publique.By default, it does not have access to any non-public data. Une méthode dynamique hébergée anonymement peut avoir une capacité restreinte d’ignorer les contrôles de visibilité du compilateur JIT, s' ReflectionPermission il a ReflectionPermissionFlag.RestrictedMemberAccess été accordé avec l’indicateur.An anonymously hosted dynamic method can have restricted ability to skip the JIT compiler's visibility checks, if it has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag. Le niveau de confiance de l’assembly dont les membres non publics sont accessibles par la méthode dynamique doit être égal à ou à un sous-ensemble du niveau de confiance de la pile des appels qui a émis la méthode dynamique.The trust level of the assembly whose non-public members are accessed by the dynamic method must be equal to, or a subset of, the trust level of the call stack that emitted the dynamic method. Pour plus d’informations sur les méthodes dynamiques hébergées anonymement, consultez procédure pas à pas : Émission de code dans des scénariosde confiance partielle.For more information about anonymously hosted dynamic methods, see Walkthrough: Emitting Code in Partial Trust Scenarios.

  • Si la méthode dynamique est associée à un module que vous spécifiez, la méthode dynamique est effectivement globale pour ce module.If the dynamic method is associated with a module that you specify, the dynamic method is effectively global to that module. Il peut accéder à tous les types du module et internal àFriend tous les membres (dans Visual Basic) des types.It can access all types in the module and all internal (Friend in Visual Basic) members of the types. Vous pouvez associer une méthode dynamique à n’importe quel module, que vous ayez créé le module, à condition qu’une ReflectionPermission demande avec RestrictedMemberAccess l’indicateur puisse être satisfaite par la pile des appels qui contient votre code.You can associate a dynamic method with any module, regardless of whether you created the module, provided that a demand for ReflectionPermission with the RestrictedMemberAccess flag can be satisfied by the call stack that includes your code. Si l' ReflectionPermissionFlag.MemberAccess indicateur est inclus dans l’octroi, la méthode dynamique peut ignorer les contrôles de visibilité du compilateur JIT et accéder aux données privées de tous les types déclarés dans le module ou dans tout autre module de n’importe quel assembly.If the ReflectionPermissionFlag.MemberAccess flag is included in the grant, the dynamic method can skip the JIT compiler's visibility checks and access the private data of all types declared in the module or in any other module in any assembly.

    Notes

    Quand vous spécifiez le module auquel une méthode dynamique est associée, ce module ne doit pas être dans l’assembly fourni par le système qui est utilisé pour l’hébergement anonyme.When you specify the module with which a dynamic method is associated, that module must not be in the system-provided assembly that is used for anonymous hosting.

  • Si la méthode dynamique est associée à un type que vous spécifiez, elle a accès à tous les membres du type, quel que soit le niveau d’accès.If the dynamic method is associated with a type that you specify, it has access to all members of the type, regardless of access level. En outre, les contrôles de visibilité JIT peuvent être ignorés.In addition, JIT visibility checks can be skipped. Cela donne à la méthode dynamique l’accès aux données privées d’autres types déclarés dans le même module ou dans tout autre module de n’importe quel assembly.This gives the dynamic method access to the private data of other types declared in the same module or in any other module in any assembly. Vous pouvez associer une méthode dynamique à n’importe quel type, mais votre code doit ReflectionPermission être accordé avec RestrictedMemberAccess les MemberAccess indicateurs et.You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

Le tableau suivant indique les types et les membres qui sont accessibles à une méthode dynamique hébergée anonymement, avec et sans contrôles de visibilité JIT, ReflectionPermission selon que RestrictedMemberAccess l’indicateur est accordé ou non.The following table shows which types and members are accessible to an anonymously hosted dynamic method, with and without JIT visibility checks, depending on whether ReflectionPermission with the RestrictedMemberAccess flag is granted.

Sans RestrictedMemberAccessWithout RestrictedMemberAccess Avec RestrictedMemberAccessWith RestrictedMemberAccess
Sans ignorer les contrôles de visibilité JITWithout skipping JIT visibility checks Membres publics de types publics dans n’importe quel assembly.Public members of public types in any assembly. Membres publics de types publics dans n’importe quel assembly.Public members of public types in any assembly.
Contrôles de visibilité JIT ignorés, avec des restrictionsSkipping JIT visibility checks, with restrictions Membres publics de types publics dans n’importe quel assembly.Public members of public types in any assembly. Tous les membres de tous les types, uniquement dans les assemblys dont les niveaux de confiance sont inférieurs ou égaux au niveau de confiance de l’assembly qui a émis la méthode dynamique.All members of all types, only in assemblies whose trust levels are equal to or less than the trust level of the assembly that emitted the dynamic method.

Notes

Avant le .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, émettant du code requis ReflectionPermission avec l' ReflectionPermissionFlag.ReflectionEmit indicateur.Prior to the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, emitting code required ReflectionPermission with the ReflectionPermissionFlag.ReflectionEmit flag. Cette autorisation est incluse par défaut dans les jeux d’autorisations FullTrust et LocalIntranet nommés, mais pas dans le jeu d’autorisations Internet.This permission is included by default in the FullTrust and LocalIntranet named permission sets, but not in the Internet permission set. Par .NET Framework.NET Framework conséquent, dans les versions antérieures d’une bibliothèque, peut être utilisé avec des autorisations Internet uniquement si elle a l' SecurityCriticalAttribute attribut et exécute également ReflectionEmitun Assert pour.Therefore, in earlier versions of the .NET Framework.NET Framework a library can be used with Internet permissions only if it has the SecurityCriticalAttribute attribute and also executes an Assert for ReflectionEmit. Ces bibliothèques nécessitent une revue minutieuse de la sécurité, car les erreurs de codage peuvent entraîner des failles de sécurité.Such libraries require careful security review because coding errors could result in security holes. Le .NET Framework 2,0 SP1.NET Framework 2.0 SP1 permet au code d’être émis dans des scénarios de confiance partielle sans émettre de demandes de sécurité, car la génération de code n’est pas fondamentalement une opération nécessitant des privilèges.The .NET Framework 2,0 SP1.NET Framework 2.0 SP1 allows code to be emitted in partial trust scenarios without issuing any security demands, because generating code is not inherently a privileged operation. Autrement dit, le code généré n'a pas plus d'autorisations que l'assembly qui l'émet.That is, the generated code has no more permissions than the assembly that emits it. Ceci permet aux bibliothèques qui émettent du code d'être transparentes de sécurité et supprime la nécessité de déclarer ReflectionEmit, ce qui simplifie l'écriture d'une bibliothèque sécurisée.This allows libraries that emit code to be security transparent and removes the need to assert ReflectionEmit, which simplifies the task of writing a secure library. Pour utiliser cette fonctionnalité, votre application doit cibler le .NET Framework 3.5.NET Framework 3.5 ou une version ultérieure.To use this feature, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Le tableau suivant indique les types et les membres qui sont accessibles à une méthode dynamique qui est associée à un module ou à un type dans un module.The following table shows which types and members are accessible to a dynamic method that is associated with a module or with a type in a module.

Associé au moduleAssociated with module Associé au typeAssociated with type
Sans ignorer les contrôles de visibilité JITWithout skipping JIT visibility checks Membres publics et internes de types publics, internes et privés dans le module.Public and internal members of public, internal, and private types in the module.

Membres publics de types publics dans n’importe quel assembly.Public members of public types in any assembly.
Tous les membres du type associé.All members of the associated type. Membres publics et internes de tous les autres types dans le module.Public and internal members of all the other types in the module.

Membres publics de types publics dans n’importe quel assembly.Public members of public types in any assembly.
Contrôles de visibilité JIT ignorésSkipping JIT visibility checks Tous les membres de tous les types dans un assembly.All members of all types in any assembly. Tous les membres de tous les types dans un assembly.All members of all types in any assembly.

Une méthode dynamique qui est associée à un module a les autorisations de ce module.A dynamic method that is associated with a module has the permissions of that module. Une méthode dynamique qui est associée à un type a les autorisations du module contenant ce type.A dynamic method that is associated with a type has the permissions of the module containing that type.

Les méthodes dynamiques et leurs paramètres n’ont pas besoin d’être nommés, mais vous pouvez spécifier des noms pour faciliter le débogage.Dynamic methods and their parameters do not have to be named, but you can specify names to assist in debugging. Les attributs personnalisés ne sont pas pris en charge sur les méthodes dynamiques ou leurs paramètres.Custom attributes are not supported on dynamic methods or their parameters.

Bien que les méthodes static dynamiques soientShared des méthodes (méthodes dans Visual Basic), les règles assouplies pour la .NET Framework 2.0.NET Framework 2.0 liaison de délégués introduite dans autorisent la liaison d’une méthode dynamique à un objet, afin qu’elle agisse comme une méthode d’instance quand appelée à l’aide de cette instance de délégué.Although dynamic methods are static methods (Shared methods in Visual Basic), the relaxed rules for delegate binding introduced in the .NET Framework 2.0.NET Framework 2.0 allow a dynamic method to be bound to an object, so that it acts like an instance method when called using that delegate instance. Un exemple qui illustre cela est fourni pour la CreateDelegate(Type, Object) surcharge de méthode.An example that demonstrates this is provided for the CreateDelegate(Type, Object) method overload.

Notes

Dans, .NET Framework 2.0.NET Framework 2.0les méthodes dynamiques ne prennent pas en charge les informations de symboles, autrement dit, les noms de variables locales et le mappage de numéro de ligne.In the .NET Framework 2.0.NET Framework 2.0, dynamic methods do not support symbol information, that is, local variable names and line-number mapping. Cette limitation peut être supprimée dans une version ultérieure.This limitation might be removed in a future version. Vous pouvez utiliser AssemblyBuilder pendant le développement pour simplifier le débogage du langage MSIL (Microsoft Intermediate Language) généré, puis basculer vers les méthodes dynamiques pendant le déploiement ILGenerator final, car les appels sont les mêmes dans les deux cas.You can use AssemblyBuilder during development to simplify debugging the generated Microsoft intermediate language (MSIL), and then switch to dynamic methods during final deployment, because the ILGenerator calls are the same in both cases.

VérificationVerification

La liste suivante résume les conditions dans lesquelles les méthodes dynamiques peuvent contenir du code non vérifiable.The following list summarizes the conditions under which dynamic methods can contain unverifiable code. (Par exemple, une méthode dynamique est non vérifiable si sa propriété InitLocals a la falsevaleur.)(For example, a dynamic method is unverifiable if its InitLocals property is set to false.)

  • Une méthode dynamique qui est associée à un assembly critique de sécurité est également critique de sécurité et peut ignorer la vérification.A dynamic method that is associated with a security-critical assembly is also security-critical, and can skip verification. Par exemple, un assembly sans attributs de sécurité exécuté en tant qu’application de bureau est traité comme étant critique de sécurité par le Runtime.For example, an assembly without security attributes that is run as a desktop application is treated as security-critical by the runtime. Si vous associez une méthode dynamique à l’assembly, la méthode dynamique peut contenir du code non vérifiable.If you associate a dynamic method with the assembly, the dynamic method can contain unverifiable code.

  • Si une méthode dynamique qui contient du code non vérifiable est associée à un assembly qui a une transparence de niveau 1, le compilateur juste-à-temps (JIT, Just-in-Time) injecte une demande de sécurité.If a dynamic method that contains unverifiable code is associated with an assembly that has level 1 transparency, the just-in-time (JIT) compiler injects a security demand. La demande réussit uniquement si la méthode dynamique est exécutée par du code d’un niveau de confiance suffisant.The demand succeeds only if the dynamic method is executed by fully trusted code. Consultez code transparent de sécurité, niveau 1.See Security-Transparent Code, Level 1.

  • Si une méthode dynamique qui contient du code non vérifiable est associée à un assembly qui a une transparence de niveau 2 (comme mscorlib. dll), elle lève une exception (injectée par le compilateur JIT) au lieu d’effectuer une demande de sécurité.If a dynamic method that contains unverifiable code is associated with an assembly that has level 2 transparency (such as mscorlib.dll), it throws an exception (injected by the JIT compiler) instead of making a security demand. Consultez code transparent de sécurité, niveau 2.See Security-Transparent Code, Level 2.

  • Une méthode dynamique hébergée anonymement qui contient du code non vérifiable lève toujours une exception.An anonymously hosted dynamic method that contains unverifiable code always throws an exception. Elle ne peut jamais ignorer la vérification, même si elle est créée et exécutée par du code d’un niveau de confiance suffisant.It can never skip verification, even if it is created and executed by fully trusted code.

L’exception levée pour le code non vérifiable varie selon le mode d’appel de la méthode dynamique.The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. Si vous appelez une méthode dynamique à l’aide d’un délégué retourné CreateDelegate à partir de VerificationException la méthode, une exception est levée.If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. Si vous appelez la méthode dynamique à l’aide Invoke de la méthode TargetInvocationException , une exception est levée VerificationExceptionavec un interne.If you invoke the dynamic method by using the Invoke method, a TargetInvocationException is thrown with an inner VerificationException.

Constructeurs

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

Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, les attributs, les conventions d'appel, le type de retour, les types de paramètres, le module et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage Microsoft Intermediate Language (MSIL) de la méthode dynamique.Creates a dynamic method that is global to a module, specifying the method name, attributes, calling convention, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

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

Crée une méthode dynamique, en spécifiant le nom de la méthode, les attributs, la convention d'appel, le type de retour, les types de paramètres, le type auquel la méthode dynamique est associée de manière logique, et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage MSIL de la méthode dynamique.Creates a dynamic method, specifying the method name, attributes, calling convention, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[])

Initialise une méthode dynamique hébergée de manière anonyme, en spécifiant le nom de la méthode, le type de retour et les types de paramètre.Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

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

Initialise une méthode dynamique hébergée de façon anonyme, en spécifiant le nom de la méthode, le type de retour, les types de paramètre et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage MSIL (Microsoft Intermediate Language) de la méthode dynamique.Initializes an anonymously hosted dynamic method, specifying the method name, return type, parameter types, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

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

Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, le type de retour, les types de paramètres et le module.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, and module.

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

Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, le type de retour, les types de paramètres, le module et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage Microsoft Intermediate Language (MSIL) de la méthode dynamique.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

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

Crée une méthode dynamique, en spécifiant le nom de la méthode, le type de retour, les types de paramètres et le type auquel la méthode dynamique est associée de manière logique.Creates a dynamic method, specifying the method name, return type, parameter types, and the type with which the dynamic method is logically associated.

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

Crée une méthode dynamique, en spécifiant le nom de la méthode, le type de retour, les types de paramètres, le type auquel la méthode dynamique est associée de manière logique, et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le code MSIL de la méthode dynamique.Creates a dynamic method, specifying the method name, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

Propriétés

Attributes

Obtient les attributs spécifiés au moment de la création de la méthode dynamique.Gets the attributes specified when the dynamic method was created.

CallingConvention

Obtient la convention d'appel spécifiée au moment de la création de la méthode dynamique.Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters

Obtient une valeur indiquant si une méthode générique contient des paramètres de type générique non attribués.Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(Hérité de MethodInfo)
CustomAttributes

Obtient une collection qui contient les attributs personnalisés de ce membre.Gets a collection that contains this member's custom attributes.

(Hérité de MemberInfo)
DeclaringType

Obtient le type qui déclare la méthode (toujours null pour les méthodes dynamiques).Gets the type that declares the method, which is always null for dynamic methods.

InitLocals

Obtient ou définit une valeur qui indique si les variables locales contenues dans la méthode sont initialisées à zéro.Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract

Obtient une valeur indiquant si la méthode est abstraite.Gets a value indicating whether the method is abstract.

(Hérité de MethodBase)
IsAssembly

Obtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par Assembly, c'est-à-dire si la méthode ou le constructeur est visible au maximum par d'autres types du même assembly, et n'est pas visible par des types dérivés à l'extérieur de l'assembly.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Hérité de MethodBase)
IsCollectible

Obtient une valeur qui indique si cet objet MemberInfo fait partie d’un assembly contenu dans un AssemblyLoadContext pouvant être collecté.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Hérité de MemberInfo)
IsConstructedGenericMethod (Hérité de MethodBase)
IsConstructor

Obtient une valeur indiquant si la méthode est un constructeur.Gets a value indicating whether the method is a constructor.

(Hérité de MethodBase)
IsFamily

Obtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par Family, c'est-à-dire si la méthode ou le constructeur est visible uniquement dans sa classe et dans ses classes dérivées.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Hérité de MethodBase)
IsFamilyAndAssembly

Obtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par FamANDAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées, mais uniquement si elles se trouvent dans le même assembly.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(Hérité de MethodBase)
IsFamilyOrAssembly

Obtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par FamORAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Hérité de MethodBase)
IsFinal

Obtient une valeur indiquant si cette méthode est final.Gets a value indicating whether this method is final.

(Hérité de MethodBase)
IsGenericMethod

Obtient une valeur indiquant si la méthode actuelle est une méthode générique.Gets a value indicating whether the current method is a generic method.

(Hérité de MethodInfo)
IsGenericMethodDefinition

Obtient une valeur indiquant si le MethodInfo actuel représente la définition d'une méthode générique.Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

(Hérité de MethodInfo)
IsHideBySig

Obtient une valeur indiquant si seul un membre du même type, doté d'une signature identique, est caché dans la classe dérivée.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Hérité de MethodBase)
IsPrivate

Obtient une valeur indiquant si ce membre est privé.Gets a value indicating whether this member is private.

(Hérité de MethodBase)
IsPublic

Obtient une valeur indiquant s'il s'agit d'une méthode publique.Gets a value indicating whether this is a public method.

(Hérité de MethodBase)
IsSecurityCritical

Obtient une valeur qui indique si la méthode dynamique actuelle est critique de sécurité (security-critical) ou critique sécurisée (security-safe-critical) et peut par conséquent exécuter des opérations critiques.Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

IsSecuritySafeCritical

Obtient une valeur qui indique si la méthode dynamique actuelle est critique sécurisée au niveau de confiance actuel ; autrement dit, si elle peut exécuter des opérations critiques et être accessible par du code transparent.Gets a value that indicates whether the current dynamic method is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

IsSecurityTransparent

Obtient une valeur qui indique si la méthode dynamique actuelle est transparente au niveau de confiance actuel et ne peut par conséquent pas exécuter d'opérations critiques.Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSpecialName

Obtient une valeur indiquant si cette méthode est dotée d'un nom spécial.Gets a value indicating whether this method has a special name.

(Hérité de MethodBase)
IsStatic

Obtient une valeur indiquant si la méthode est static.Gets a value indicating whether the method is static.

(Hérité de MethodBase)
IsVirtual

Obtient une valeur indiquant si la méthode est virtual.Gets a value indicating whether the method is virtual.

(Hérité de MethodBase)
MemberType

Obtient une MemberTypes valeur indiquant que ce membre est une méthode.Gets a MemberTypes value indicating that this member is a method.

(Hérité de MethodInfo)
MetadataToken

Obtient une valeur qui identifie un élément de métadonnées.Gets a value that identifies a metadata element.

(Hérité de MemberInfo)
MethodHandle

Non pris en charge pour les méthodes dynamiques.Not supported for dynamic methods.

MethodImplementationFlags
Module

Obtient le module auquel la méthode dynamique est associée de manière logique.Gets the module with which the dynamic method is logically associated.

Name

Obtient le nom de la méthode dynamique.Gets the name of the dynamic method.

ReflectedType

Obtient la classe qui a été utilisée lors d'une réflexion pour obtenir cette méthode.Gets the class that was used in reflection to obtain the method.

ReturnParameter

Obtient le paramètre de retour de la méthode dynamique.Gets the return parameter of the dynamic method.

ReturnType

Obtient le type de la valeur de retour pour la méthode dynamique.Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes

Obtient les attributs personnalisés du type de retour de la méthode dynamique.Gets the custom attributes of the return type for the dynamic method.

Méthodes

CreateDelegate(Type)

Exécute la méthode dynamique et crée un délégué qui peut être utilisé pour l’exécuter.Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object)

Exécute la méthode dynamique et crée un délégué qui peut être utilisé pour l'exécuter, en spécifiant le type délégué et un objet auquel le délégué est lié.Completes the dynamic method and creates a delegate that can be used to execute it, specifying the delegate type and an object the delegate is bound to.

DefineParameter(Int32, ParameterAttributes, String)

Définit un paramètre de la méthode dynamique.Defines a parameter of the dynamic method.

Equals(Object)

Retourne une valeur qui indique si cette instance est égale à un objet spécifié.Returns a value that indicates whether this instance is equal to a specified object.

(Hérité de MethodInfo)
GetBaseDefinition()

Retourne l'implémentation de base de la méthode.Returns the base implementation for the method.

GetCustomAttributes(Boolean)

Retourne tous les attributs personnalisés définis pour la méthode.Returns all the custom attributes defined for the method.

GetCustomAttributes(Type, Boolean)

Retourne les attributs personnalisés du type spécifié qui a été appliqué à la méthode.Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributesData()

Renvoie une liste d’objets CustomAttributeData représentant des données sur les attributs qui ont été appliqués au membre cible.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Hérité de MemberInfo)
GetDynamicILInfo()

Retourne un objet DynamicILInfo qui peut être utilisé pour générer un corps de méthode à partir de jetons de métadonnées, de portées et de flux MSIL (Microsoft Intermediate Language).Returns a DynamicILInfo object that can be used to generate a method body from metadata tokens, scopes, and Microsoft intermediate language (MSIL) streams.

GetGenericArguments()

Retourne un tableau d'objets Type qui représentent les arguments de type d'une méthode générique ou les paramètres de type d'une définition de méthode générique.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Hérité de MethodInfo)
GetGenericMethodDefinition()

Retourne un objet MethodInfo qui représente une définition de méthode générique à partir de laquelle la méthode actuelle peut être construite.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(Hérité de MethodInfo)
GetHashCode()

Retourne le code de hachage de cette instance.Returns the hash code for this instance.

(Hérité de MethodInfo)
GetILGenerator()

Retourne un générateur MSIL (Microsoft Intermediate Language) pour la méthode, avec une taille de flux MSIL par défaut de 64 octets.Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32)

Retourne un générateur MSIL (Microsoft Intermediate Language) pour la méthode, avec la taille de flux MSIL spécifiée.Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody()

En cas de substitution dans une classe dérivée, obtient un objet MethodBody qui donne accès au flux MSIL, aux variables locales et aux exceptions pour la méthode actuelle.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(Hérité de MethodBase)
GetMethodImplementationFlags()

Retourne les indicateurs d'implémentation de la méthode.Returns the implementation flags for the method.

GetParameters()

Retourne les paramètres de la méthode dynamique.Returns the parameters of the dynamic method.

GetType() (Hérité de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Hérité de MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Appelle la méthode dynamique à l'aide des paramètres spécifiés, sous les contraintes du binder spécifié, avec les informations de culture données.Invokes the dynamic method using the specified parameters, under the constraints of the specified binder, with the specified culture information.

Invoke(Object, Object[]) (Hérité de MethodInfo)
IsDefined(Type, Boolean)

Indique si le type d'attribut personnalisé spécifié est défini.Indicates whether the specified custom attribute type is defined.

MakeGenericMethod(Type[])

Substitue les éléments d'un tableau de types aux paramètres de type de la définition de méthode générique actuelle et retourne un objet MethodInfo représentant la méthode construite résultante.Substitutes the elements of an array of types for the type parameters of the current generic method definition, and returns a MethodInfo object representing the resulting constructed method.

(Hérité de MethodInfo)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne la signature de la méthode, représentée sous la forme d'une chaîne.Returns the signature of the method, represented as a string.

Implémentations d’interfaces explicites

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

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MemberInfo)
_MemberInfo.GetType()

Obtient un objet Type représentant la classe MemberInfo.Gets a Type object representing the MemberInfo class.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MethodBase)
_MethodBase.GetType()

Pour obtenir une description de ce membre, consultez GetType().For a description of this member, see GetType().

(Hérité de MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Hérité de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MethodBase)
_MethodBase.IsAbstract

Pour obtenir une description de ce membre, consultez IsAbstract.For a description of this member, see IsAbstract.

(Hérité de MethodBase)
_MethodBase.IsAssembly

Pour obtenir une description de ce membre, consultez IsAssembly.For a description of this member, see IsAssembly.

(Hérité de MethodBase)
_MethodBase.IsConstructor

Pour obtenir une description de ce membre, consultez IsConstructor.For a description of this member, see IsConstructor.

(Hérité de MethodBase)
_MethodBase.IsFamily

Pour obtenir une description de ce membre, consultez IsFamily.For a description of this member, see IsFamily.

(Hérité de MethodBase)
_MethodBase.IsFamilyAndAssembly

Pour obtenir une description de ce membre, consultez IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Hérité de MethodBase)
_MethodBase.IsFamilyOrAssembly

Pour obtenir une description de ce membre, consultez IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Hérité de MethodBase)
_MethodBase.IsFinal

Pour obtenir une description de ce membre, consultez IsFinal.For a description of this member, see IsFinal.

(Hérité de MethodBase)
_MethodBase.IsHideBySig

Pour obtenir une description de ce membre, consultez IsHideBySig.For a description of this member, see IsHideBySig.

(Hérité de MethodBase)
_MethodBase.IsPrivate

Pour obtenir une description de ce membre, consultez IsPrivate.For a description of this member, see IsPrivate.

(Hérité de MethodBase)
_MethodBase.IsPublic

Pour obtenir une description de ce membre, consultez IsPublic.For a description of this member, see IsPublic.

(Hérité de MethodBase)
_MethodBase.IsSpecialName

Pour obtenir une description de ce membre, consultez IsSpecialName.For a description of this member, see IsSpecialName.

(Hérité de MethodBase)
_MethodBase.IsStatic

Pour obtenir une description de ce membre, consultez IsStatic.For a description of this member, see IsStatic.

(Hérité de MethodBase)
_MethodBase.IsVirtual

Pour obtenir une description de ce membre, consultez IsVirtual.For a description of this member, see IsVirtual.

(Hérité de MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MethodInfo)
_MethodInfo.GetType()

Fournit l'accès à la méthode GetType() à partir de COM.Provides access to the GetType() method from COM.

(Hérité de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Hérité de MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Hérité de MemberInfo)

Méthodes d’extension

GetCustomAttribute(MemberInfo, Type)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Indique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Indique si les attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié, et, éventuellement, appliqués à ses ancêtres.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Obtient un jeton de métadonnées pour le membre donné, s’il est disponible.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Retourne une valeur qui indique si un jeton de métadonnées est disponible pour le membre spécifié.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

Récupère un objet qui représente la méthode spécifiée dans la classe de base directe ou indirecte où la méthode a été déclarée la première fois.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

S’applique à

Voir aussi