DynamicMethod Classe

Definizione

Definisce e rappresenta un metodo dinamico che può essere compilato, eseguito e annullato.Defines and represents a dynamic method that can be compiled, executed, and discarded. I metodi annullati possono essere sottoposti a Garbage Collection.Discarded methods are available for garbage collection.

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
Ereditarietà
Attributi

Esempio

Nell'esempio di codice seguente viene creato un metodo dinamico che accetta due parametri.The following code example creates a dynamic method that takes two parameters. Nell'esempio viene emesso un corpo di funzione semplice che stampa il primo parametro nella console e nell'esempio viene utilizzato il secondo parametro come valore restituito del metodo.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. Nell'esempio viene completato il metodo creando un delegato, viene richiamato il delegato con parametri diversi e infine viene richiamato il metodo dinamico utilizzando il Invoke metodo.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

Commenti

È possibile usare la DynamicMethod classe per generare ed eseguire un metodo in fase di esecuzione, senza dover generare un assembly dinamico e un tipo dinamico per contenere il metodo.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. Il codice eseguibile creato dal compilatore JIT (just-in-Time) viene recuperato quando l' DynamicMethod oggetto viene recuperato.The executable code created by the just-in-time (JIT) compiler is reclaimed when the DynamicMethod object is reclaimed. I metodi dinamici rappresentano il modo più efficiente per generare ed eseguire piccole quantità di codice.Dynamic methods are the most efficient way to generate and execute small amounts of code.

Un metodo dinamico può essere ospitato anonimamente oppure può essere associato logicamente a un modulo o a un tipo.A dynamic method can be anonymously hosted, or it can be logically associated with a module or with a type.

  • Se il metodo dinamico è ospitato anonimamente, si trova in un assembly fornito dal sistema e pertanto è isolato da altro codice.If the dynamic method is anonymously hosted, it is located in a system-provided assembly, and therefore is isolated from other code. Per impostazione predefinita, non ha accesso a dati non pubblici.By default, it does not have access to any non-public data. Un metodo dinamico ospitato anonimamente può avere la possibilità limitata di ignorare i controlli di visibilità del compilatore JIT, se è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag.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. Il livello di attendibilità dell'assembly i cui membri non pubblici sono accessibili dal metodo dinamico deve essere uguale o un subset di, il livello di attendibilità dello stack di chiamate che ha generato il metodo dinamico.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. Per ulteriori informazioni sui metodi dinamici ospitati anonimamente, vedere procedura dettagliata: creazione di codice in scenari di attendibilità parziale.For more information about anonymously hosted dynamic methods, see Walkthrough: Emitting Code in Partial Trust Scenarios.

  • Se il metodo dinamico è associato a un modulo specificato, il metodo dinamico è effettivamente globale per tale modulo.If the dynamic method is associated with a module that you specify, the dynamic method is effectively global to that module. Può accedere a tutti i tipi nel modulo e a tutti i internal Friend membri (in Visual Basic) dei tipi.It can access all types in the module and all internal (Friend in Visual Basic) members of the types. È possibile associare un metodo dinamico a qualsiasi modulo, indipendentemente dal fatto che sia stato creato il modulo, a condizione che una richiesta di ReflectionPermission con il RestrictedMemberAccess flag possa essere soddisfatta dallo stack di chiamate che include il codice.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. Se il ReflectionPermissionFlag.MemberAccess flag è incluso nella concessione, il metodo dinamico può ignorare i controlli di visibilità del compilatore JIT e accedere ai dati privati di tutti i tipi dichiarati nel modulo o in qualsiasi altro modulo di qualsiasi 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.

    Nota

    Quando si specifica il modulo a cui è associato un metodo dinamico, tale modulo non deve trovarsi nell'assembly fornito dal sistema usato per l'hosting anonimo.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.

  • Se il metodo dinamico è associato a un tipo specificato, ha accesso a tutti i membri del tipo, indipendentemente dal livello di accesso.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. Inoltre, i controlli di visibilità JIT possono essere ignorati.In addition, JIT visibility checks can be skipped. Ciò consente al metodo dinamico di accedere ai dati privati di altri tipi dichiarati nello stesso modulo o in qualsiasi altro modulo di qualsiasi 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. È possibile associare un metodo dinamico a qualsiasi tipo, ma il codice deve essere concesso ReflectionPermission con i RestrictedMemberAccess flag e MemberAccess .You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

La tabella seguente illustra i tipi e i membri accessibili a un metodo dinamico ospitato anonimamente, con e senza controlli di visibilità JIT, a seconda che ReflectionPermission sia stato RestrictedMemberAccess concesso il flag.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.

Senza RestrictedMemberAccessWithout RestrictedMemberAccess Con RestrictedMemberAccessWith RestrictedMemberAccess
Senza ignorare i controlli di visibilità JITWithout skipping JIT visibility checks Membri pubblici di tipi pubblici in qualsiasi assembly.Public members of public types in any assembly. Membri pubblici di tipi pubblici in qualsiasi assembly.Public members of public types in any assembly.
Ignorare i controlli di visibilità JIT con restrizioniSkipping JIT visibility checks, with restrictions Membri pubblici di tipi pubblici in qualsiasi assembly.Public members of public types in any assembly. Tutti i membri di tutti i tipi, solo negli assembly i cui livelli di attendibilità sono uguali o inferiori al livello di attendibilità dell'assembly che ha emesso il metodo dinamico.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.

Nota

Prima di .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 , la creazione di codice richiedeva ReflectionPermission con il ReflectionPermissionFlag.ReflectionEmit flag.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. Questa autorizzazione è inclusa per impostazione predefinita nei set di autorizzazioni denominati FullTrust e LocalIntranet, ma non nel set di autorizzazioni Internet.This permission is included by default in the FullTrust and LocalIntranet named permission sets, but not in the Internet permission set. Pertanto, nelle versioni precedenti di .NET Framework.NET Framework una libreria può essere utilizzata con le autorizzazioni Internet solo se dispone dell' SecurityCriticalAttribute attributo ed esegue anche un Assert per ReflectionEmit .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. Tali librerie richiedono un'attenta revisione della sicurezza perché eventuali errori nel codice potrebbe produrre delle vulnerabilità.Such libraries require careful security review because coding errors could result in security holes. .NET Framework 2.0 SP1.NET Framework 2.0 SP1 consente di generare codice in scenari con attendibilità parziale senza creare alcuna richiesta di sicurezza, poiché la generazione di codice non è implicitamente un'operazione con privilegi.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. Ovvero, il codice generato non dispone di ulteriori autorizzazioni rispetto all'assembly che lo genera.That is, the generated code has no more permissions than the assembly that emits it. Questo consente alle librerie che generano il codice di essere SecurityTransparent ed elimina la necessità di asserire ReflectionEmit, che semplifica l'attività di scrittura di una libreria protetta.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. Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this feature, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

La tabella seguente illustra i tipi e i membri accessibili a un metodo dinamico associato a un modulo o a un tipo in un modulo.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.

Associato al moduloAssociated with module Associato al tipoAssociated with type
Senza ignorare i controlli di visibilità JITWithout skipping JIT visibility checks Membri pubblici e interni di tipi pubblici, interni e privati nel modulo.Public and internal members of public, internal, and private types in the module.

Membri pubblici di tipi pubblici in qualsiasi assembly.Public members of public types in any assembly.
Tutti i membri del tipo associato.All members of the associated type. Membri pubblici e interni di tutti gli altri tipi del modulo.Public and internal members of all the other types in the module.

Membri pubblici di tipi pubblici in qualsiasi assembly.Public members of public types in any assembly.
I controlli di visibilità JIT verranno ignoratiSkipping JIT visibility checks Tutti i membri di tutti i tipi in qualsiasi assembly.All members of all types in any assembly. Tutti i membri di tutti i tipi in qualsiasi assembly.All members of all types in any assembly.

Un metodo dinamico associato a un modulo dispone delle autorizzazioni del modulo.A dynamic method that is associated with a module has the permissions of that module. Un metodo dinamico associato a un tipo dispone delle autorizzazioni del modulo che contiene il tipo.A dynamic method that is associated with a type has the permissions of the module containing that type.

I metodi dinamici e i relativi parametri non devono essere denominati, ma è possibile specificare nomi per facilitare il debug.Dynamic methods and their parameters do not have to be named, but you can specify names to assist in debugging. Gli attributi personalizzati non sono supportati nei metodi dinamici o nei relativi parametri.Custom attributes are not supported on dynamic methods or their parameters.

Sebbene i metodi dinamici siano static metodi ( Shared metodi in Visual Basic), le regole di attenuazione per l'associazione di delegati introdotti in .NET Framework 2.0.NET Framework 2.0 consentono di associare un metodo dinamico a un oggetto, in modo che funga da metodo di istanza quando viene chiamato utilizzando l'istanza del delegato.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 esempio che illustra questa condizione viene fornito per l' CreateDelegate(Type, Object) Overload del metodo.An example that demonstrates this is provided for the CreateDelegate(Type, Object) method overload.

Nota

In i .NET Framework 2.0.NET Framework 2.0 metodi dinamici non supportano le informazioni sui simboli, ovvero i nomi delle variabili locali e il mapping del numero di riga.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. Questa limitazione potrebbe essere rimossa in una versione futura.This limitation might be removed in a future version. È possibile utilizzare AssemblyBuilder durante lo sviluppo per semplificare il debug del codice MSIL (Microsoft Intermediate Language) generato, quindi passare a metodi dinamici durante la distribuzione finale, in quanto le ILGenerator chiamate sono le stesse in entrambi i casi.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.

VerificaVerification

Nell'elenco seguente sono riepilogate le condizioni in base alle quali i metodi dinamici possono contenere codice non verificabile.The following list summarizes the conditions under which dynamic methods can contain unverifiable code. (Ad esempio, un metodo dinamico non è verificabile se la relativa InitLocals proprietà è impostata su false .)(For example, a dynamic method is unverifiable if its InitLocals property is set to false.)

  • Un metodo dinamico associato a un assembly critico per la sicurezza è anche critico per la sicurezza e può ignorare la verifica.A dynamic method that is associated with a security-critical assembly is also security-critical, and can skip verification. Ad esempio, un assembly senza attributi di sicurezza eseguito come applicazione desktop viene considerato critico per la sicurezza dal runtime.For example, an assembly without security attributes that is run as a desktop application is treated as security-critical by the runtime. Se si associa un metodo dinamico all'assembly, il metodo dinamico può contenere codice non verificabile.If you associate a dynamic method with the assembly, the dynamic method can contain unverifiable code.

  • Se un metodo dinamico che contiene codice non verificabile è associato a un assembly con trasparenza di livello 1, il compilatore just-in-time (JIT) inserisce una richiesta di sicurezza.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 richiesta ha esito positivo solo se il metodo dinamico viene eseguito da codice completamente attendibile.The demand succeeds only if the dynamic method is executed by fully trusted code. Vedere codice SecurityTransparent, livello 1.See Security-Transparent Code, Level 1.

  • Se un metodo dinamico che contiene codice non verificabile è associato a un assembly con trasparenza di livello 2 (ad esempio mscorlib.dll), viene generata un'eccezione, inserita dal compilatore JIT, anziché eseguire una richiesta di sicurezza.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. Vedere codice SecurityTransparent, livello 2.See Security-Transparent Code, Level 2.

  • Un metodo dinamico ospitato anonimamente che contiene codice non verificabile genera sempre un'eccezione.An anonymously hosted dynamic method that contains unverifiable code always throws an exception. Non può mai ignorare la verifica, anche se viene creata ed eseguita da codice completamente attendibile.It can never skip verification, even if it is created and executed by fully trusted code.

L'eccezione generata per il codice non verificabile varia a seconda del modo in cui viene richiamato il metodo dinamico.The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. Se si richiama un metodo dinamico usando un delegato restituito dal CreateDelegate metodo, VerificationException viene generata un'eccezione.If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. Se si richiama il metodo dinamico usando il Invoke metodo, TargetInvocationException viene generata un'eccezione con un oggetto interno VerificationException .If you invoke the dynamic method by using the Invoke method, a TargetInvocationException is thrown with an inner VerificationException.

Costruttori

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

Crea un metodo dinamico globale per un metodo, specificando il nome del metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametro, il modulo e se i controlli di visibilità JIT possono essere ignorati per i tipi e i membri cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.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)

Crea un metodo dinamico, specificando il nome del metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametro, il tipo a cui il metodo dinamico è associato in modo logico e se i controlli di visibilità JIT possono essere ignorati per i tipi e i membri cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.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[])

Inizializza un metodo dinamico ospitato anonimamente, specificando il nome del metodo, il tipo restituito e i tipi di parametro.Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

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

Inizializza un metodo dinamico ospitato anonimamente, specificando il nome del metodo, il tipo restituito, i tipi di parametro e se i controlli di visibilità JIT possono essere ignorati per i tipi e i membri cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.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)

Crea un metodo dinamico che è globale per un modulo, specificando il nome del metodo, il tipo restituito, i tipi di parametro e il modulo.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)

Crea un metodo dinamico globale per un modulo, specificando il nome del metodo, il tipo restituito, i tipi di parametri e il modulo e indicando se deve essere ignorato il controllo di visibilità JIT per i tipi e i membri del metodo dinamico a cui accede MSIL (Microsoft Intermediate Language).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)

Crea un metodo dinamico, specificando il nome del metodo, il tipo restituito, i parametri di tipo e il tipo a cui il metodo dinamico è associato dal punto di vista logico.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)

Crea un metodo dinamico, specificando il nome del metodo, il tipo restituito, i tipi di parametro, il tipo a cui il metodo dinamico è associato in modo logico e se i controlli di visibilità JIT possono essere ignorati per i tipi e i membri cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.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.

Proprietà

Attributes

Ottiene gli attributi specificati quando il metodo dinamico è stato creato.Gets the attributes specified when the dynamic method was created.

CallingConvention

Ottiene la convenzione di chiamata specificata durante la creazione del metodo dinamico.Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters

Ottiene un valore che indica se un metodo generico contiene parametri di tipo generico non assegnati.Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(Ereditato da MethodInfo)
CustomAttributes

Ottiene una raccolta che contiene gli attributi personalizzati del membro.Gets a collection that contains this member's custom attributes.

(Ereditato da MemberInfo)
DeclaringType

Ottiene il tipo che dichiara il metodo, che è sempre null per i metodi dinamici.Gets the type that declares the method, which is always null for dynamic methods.

InitLocals

Ottiene o imposta un valore che indica se le variabili locali nel metodo sono inizializzate su zero.Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract

Ottiene un valore che indica se il metodo è astratto.Gets a value indicating whether the method is abstract.

(Ereditato da MethodBase)
IsAssembly

Ottiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da Assembly, ovvero se il metodo o costruttore è visibile al massimo ad altri tipi dello stesso assembly, ma non ai tipi derivati all'esterno dell'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.

(Ereditato da MethodBase)
IsCollectible

Ottiene un valore che indica se questo oggetto MemberInfo fa parte di un assembly conservato in un AssemblyLoadContext ritirabile.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Ereditato da MemberInfo)
IsConstructedGenericMethod (Ereditato da MethodBase)
IsConstructor

Ottiene un valore che indica se il metodo è un costruttore.Gets a value indicating whether the method is a constructor.

(Ereditato da MethodBase)
IsFamily

Ottiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da Family, ovvero se il metodo o costruttore è visibile solo all'interno della relativa classe e delle classi derivate.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.

(Ereditato da MethodBase)
IsFamilyAndAssembly

Ottiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da FamANDAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate, ma solo se appartenenti allo stesso 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.

(Ereditato da MethodBase)
IsFamilyOrAssembly

Ottiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da FamORAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate indipendentemente dalla posizione e da classi appartenenti allo stesso 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.

(Ereditato da MethodBase)
IsFinal

Ottiene un valore che indica se il metodo è final.Gets a value indicating whether this method is final.

(Ereditato da MethodBase)
IsGenericMethod

Ottiene un valore che indica se il metodo corrente è un metodo generico.Gets a value indicating whether the current method is a generic method.

(Ereditato da MethodInfo)
IsGenericMethodDefinition

Ottiene un valore che indica se la classe MethodInfo corrente rappresenta la definizione di un metodo generico.Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

(Ereditato da MethodInfo)
IsHideBySig

Ottiene un valore che indica se nella classe derivata è nascosto un solo membro dello stesso tipo che riporta esattamente la stessa firma.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Ereditato da MethodBase)
IsPrivate

Ottiene un valore che indica se questo membro è privato.Gets a value indicating whether this member is private.

(Ereditato da MethodBase)
IsPublic

Ottiene un valore che indica se si tratta di un metodo pubblico.Gets a value indicating whether this is a public method.

(Ereditato da MethodBase)
IsSecurityCritical

Ottiene un valore che indica se il metodo dinamico corrente è critico per la sicurezza o critico per la sicurezza e richiamabile da codice trasparente e può pertanto eseguire operazioni critiche.Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

IsSecurityCritical

Ottiene un valore che indica se il metodo o il costruttore corrente è critico per la sicurezza o security-safe-critical al livello di attendibilità corrente, e pertanto può eseguire operazioni critiche.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(Ereditato da MethodBase)
IsSecuritySafeCritical

Ottiene un valore che indica se il metodo dinamico corrente è critico per la sicurezza al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche e se è possibile accedervi tramite codice trasparente.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.

IsSecuritySafeCritical

Ottiene un valore che indica se il metodo o il costruttore corrente è security-safe-critical al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche ed essere richiamato da codice trasparente.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(Ereditato da MethodBase)
IsSecurityTransparent

Ottiene un valore che indica se il metodo dinamico corrente è trasparente al livello di attendibilità corrente e pertanto non può eseguire operazioni critiche.Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSecurityTransparent

Ottiene un valore che indica se il metodo o il costruttore corrente è trasparente al livello di attendibilità corrente, e pertanto non può eseguire operazioni critiche.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(Ereditato da MethodBase)
IsSpecialName

Ottiene un valore che indica se questo metodo ha un nome speciale.Gets a value indicating whether this method has a special name.

(Ereditato da MethodBase)
IsStatic

Ottiene un valore che indica se il metodo è static.Gets a value indicating whether the method is static.

(Ereditato da MethodBase)
IsVirtual

Ottiene un valore che indica se il metodo è virtual.Gets a value indicating whether the method is virtual.

(Ereditato da MethodBase)
MemberType

Ottiene un valore MemberTypes che indica che questo membro è un metodo.Gets a MemberTypes value indicating that this member is a method.

(Ereditato da MethodInfo)
MetadataToken

Ottiene un valore che identifica un elemento di metadati.Gets a value that identifies a metadata element.

(Ereditato da MemberInfo)
MethodHandle

Non supportato per metodi dinamici.Not supported for dynamic methods.

MethodHandle

Ottiene un handle alla rappresentazione interna dei metadati di un metodo.Gets a handle to the internal metadata representation of a method.

(Ereditato da MethodBase)
MethodImplementationFlags
MethodImplementationFlags

Ottiene i flag MethodImplAttributes che specificano gli attributi di implementazione di un metodo.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

(Ereditato da MethodBase)
Module

Ottiene il modulo a cui il metodo dinamico è associato in modo logico.Gets the module with which the dynamic method is logically associated.

Module

Ottiene il modulo in cui viene definito il tipo che dichiara il membro rappresentato dall'oggetto MemberInfo corrente.Gets the module in which the type that declares the member represented by the current MemberInfo is defined.

(Ereditato da MemberInfo)
Name

Ottiene il nome del metodo dinamico.Gets the name of the dynamic method.

ReflectedType

Ottiene la classe usata nella reflection per ottenere il metodo.Gets the class that was used in reflection to obtain the method.

ReflectedType

Ottiene l'oggetto classe utilizzato per ottenere questa istanza di MemberInfo.Gets the class object that was used to obtain this instance of MemberInfo.

(Ereditato da MemberInfo)
ReturnParameter

Ottiene il parametro restituito del metodo dinamico.Gets the return parameter of the dynamic method.

ReturnType

Ottiene il tipo di valore restituito per il metodo dinamico.Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes

Ottiene gli attributi personalizzati del tipo restituito per il metodo dinamico.Gets the custom attributes of the return type for the dynamic method.

ReturnTypeCustomAttributes

Ottiene gli attributi personalizzati per il tipo restituito.Gets the custom attributes for the return type.

(Ereditato da MethodInfo)

Metodi

CreateDelegate(Type)

Completa il metodo dinamico e crea un delegato che può essere usato per eseguirlo.Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object)

Completa il metodo dinamico e crea un delegato che può essere usato per eseguirlo, specificando il tipo di delegato e l'oggetto a cui il delegato è associato.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.

CreateDelegate<T>()

Crea un delegato di tipo T da questo metodo.Creates a delegate of type T from this method.

(Ereditato da MethodInfo)
CreateDelegate<T>(Object)

Crea un delegato di tipo T con la destinazione specificata da questo metodo.Creates a delegate of type T with the specified target from this method.

(Ereditato da MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)

Definisce un parametro del metodo dinamico.Defines a parameter of the dynamic method.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value that indicates whether this instance is equal to a specified object.

(Ereditato da MethodInfo)
GetBaseDefinition()

Restituisce l'implementazione di base per il metodo.Returns the base implementation for the method.

GetBaseDefinition()

Quando ne viene eseguito l'override in una classe derivata,, restituisce l'oggetto MethodInfo relativo al metodo presente nella classe base diretta o indiretta in cui il metodo rappresentato da questa istanza è stato inizialmente dichiarato.When overridden in a derived class, returns the MethodInfo object for the method on the direct or indirect base class in which the method represented by this instance was first declared.

(Ereditato da MethodInfo)
GetCustomAttributes(Boolean)

Restituisce tutti gli attributi personalizzati definiti per il metodo.Returns all the custom attributes defined for the method.

GetCustomAttributes(Boolean)

Se sottoposto a override in una classe derivata, restituisce una matrice di tutti gli attributi personalizzati applicati a questo membro.When overridden in a derived class, returns an array of all custom attributes applied to this member.

(Ereditato da MemberInfo)
GetCustomAttributes(Type, Boolean)

Restituisce gli attributi personalizzati del tipo specificato che sono stati applicati al metodo.Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributes(Type, Boolean)

Quando viene sottoposto a override in una classe derivata, questo metodo restituisce una matrice di attributi personalizzati applicati a questo membro e identificati da Type.When overridden in a derived class, returns an array of custom attributes applied to this member and identified by Type.

(Ereditato da MemberInfo)
GetCustomAttributesData()

Restituisce un elenco di oggetti CustomAttributeData che rappresentano i dati relativi agli attributi applicati al membro di destinazione.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Ereditato da MemberInfo)
GetDynamicILInfo()

Restituisce un oggetto DynamicILInfo che può essere usato per generare un corpo del metodo dai token di metadati, ambiti e flussi 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()

Restituisce una matrice di oggetti Type che rappresentano gli argomenti tipo di un metodo generico o i parametri di tipo della definizione di un metodo generico.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Ereditato da MethodInfo)
GetGenericMethodDefinition()

Restituisce un oggetto MethodInfo che rappresenta la definizione di un metodo generica da cui è possibile costruire il metodo corrente.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(Ereditato da MethodInfo)
GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

(Ereditato da MethodInfo)
GetILGenerator()

Restituisce un generatore di Microsoft Intermediate Language (MSIL) per il metodo con una dimensione di flusso MSIL predefinita di 64 byte.Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32)

Restituisce un generatore di Microsoft Intermediate Language (MSIL) per il metodo con le dimensioni del flusso MSIL specificate.Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody()

Se viene eseguito l'override in una classe derivata, ottiene un oggetto MethodBody che consente di accedere al flusso MSIL, alle variabili locali e alle eccezioni per il metodo corrente.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.

(Ereditato da MethodBase)
GetMethodImplementationFlags()

Restituisce i flag di implementazione per il metodo.Returns the implementation flags for the method.

GetMethodImplementationFlags()

Quando è sottoposto a override in una classe derivata, restituisce i flag MethodImplAttributes.When overridden in a derived class, returns the MethodImplAttributes flags.

(Ereditato da MethodBase)
GetParameters()

Restituisce i parametri del metodo dinamico.Returns the parameters of the dynamic method.

GetType()

Individua gli attributi di un metodo e consente di accedere ai relativi metadati.Discovers the attributes of a method and provides access to method metadata.

(Ereditato da MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Ereditato da MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Richiama il metodo dinamico usando i parametri specificati, con i vincoli del binder specificato e le informazioni sulle impostazioni cultura specificate.Invokes the dynamic method using the specified parameters, under the constraints of the specified binder, with the specified culture information.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Quando viene sottoposto a override in una classe derivata, richiama il metodo o il costruttore ottenuto mediante reflection con i parametri specificati.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

(Ereditato da MethodBase)
Invoke(Object, Object[])

Richiama il metodo o il costruttore ottenuto mediante reflection da questa istanza di MethodInfo.Invokes the method or constructor reflected by this MethodInfo instance.

(Ereditato da MethodInfo)
IsDefined(Type, Boolean)

Indica se il tipo di attributo personalizzato specificato è definito.Indicates whether the specified custom attribute type is defined.

IsDefined(Type, Boolean)

Quando se ne effettua l'override in una classe derivata, indica se a questo membro sono applicati uno o più attributi del tipo specificato o dei tipi derivati.When overridden in a derived class, indicates whether one or more attributes of the specified type or of its derived types is applied to this member.

(Ereditato da MemberInfo)
MakeGenericMethod(Type[])

Sostituisce con gli elementi di una matrice di tipi i parametri di tipo della definizione di metodo generica corrente e restituisce un oggetto MethodInfo che rappresenta il metodo costruito risultante.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.

(Ereditato da MethodInfo)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce la firma del metodo, rappresentata come stringa.Returns the signature of the method, represented as a string.

Implementazioni dell'interfaccia esplicita

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da MemberInfo)
_MemberInfo.GetType()

Ottiene un oggetto Type che rappresenta la classe MemberInfo.Gets a Type object representing the MemberInfo class.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da MethodBase)
_MethodBase.GetType()

Per una descrizione di questo membro, vedere GetType().For a description of this member, see GetType().

(Ereditato da MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Ereditato da MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da MethodBase)
_MethodBase.IsAbstract

Per una descrizione di questo membro, vedere IsAbstract.For a description of this member, see IsAbstract.

(Ereditato da MethodBase)
_MethodBase.IsAssembly

Per una descrizione di questo membro, vedere IsAssembly.For a description of this member, see IsAssembly.

(Ereditato da MethodBase)
_MethodBase.IsConstructor

Per una descrizione di questo membro, vedere IsConstructor.For a description of this member, see IsConstructor.

(Ereditato da MethodBase)
_MethodBase.IsFamily

Per una descrizione di questo membro, vedere IsFamily.For a description of this member, see IsFamily.

(Ereditato da MethodBase)
_MethodBase.IsFamilyAndAssembly

Per una descrizione di questo membro, vedere IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Ereditato da MethodBase)
_MethodBase.IsFamilyOrAssembly

Per una descrizione di questo membro, vedere IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Ereditato da MethodBase)
_MethodBase.IsFinal

Per una descrizione di questo membro, vedere IsFinal.For a description of this member, see IsFinal.

(Ereditato da MethodBase)
_MethodBase.IsHideBySig

Per una descrizione di questo membro, vedere IsHideBySig.For a description of this member, see IsHideBySig.

(Ereditato da MethodBase)
_MethodBase.IsPrivate

Per una descrizione di questo membro, vedere IsPrivate.For a description of this member, see IsPrivate.

(Ereditato da MethodBase)
_MethodBase.IsPublic

Per una descrizione di questo membro, vedere IsPublic.For a description of this member, see IsPublic.

(Ereditato da MethodBase)
_MethodBase.IsSpecialName

Per una descrizione di questo membro, vedere IsSpecialName.For a description of this member, see IsSpecialName.

(Ereditato da MethodBase)
_MethodBase.IsStatic

Per una descrizione di questo membro, vedere IsStatic.For a description of this member, see IsStatic.

(Ereditato da MethodBase)
_MethodBase.IsVirtual

Per una descrizione di questo membro, vedere IsVirtual.For a description of this member, see IsVirtual.

(Ereditato da MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Ereditato da MethodInfo)
_MethodInfo.GetType()

Fornisce l'accesso al metodo GetType() da COM.Provides access to the GetType() method from COM.

(Ereditato da MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto, che possono essere usate per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Ereditato da MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Ereditato da MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Ereditato da MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Restituisce una matrice di tutti gli attributi personalizzati definiti in questo membro, esclusi gli attributi denominati, oppure una matrice vuota se non sono presenti attributi personalizzati.Returns an array of all of the custom attributes defined on this member, excluding named attributes, or an empty array if there are no custom attributes.

(Ereditato da MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Restituisce una matrice di attributi personalizzati definiti in questo membro, identificati dal tipo o da una matrice vuota, se non sono presenti attributi personalizzati di quel tipo.Returns an array of custom attributes defined on this member, identified by type, or an empty array if there are no custom attributes of that type.

(Ereditato da MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Indica se per questo membro sono definite una o più istanze di attributeType.Indicates whether one or more instance of attributeType is defined on this member.

(Ereditato da MemberInfo)

Metodi di estensione

GetCustomAttribute(MemberInfo, Type)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.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)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.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)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.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)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.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)

Indica se vengono applicati attributi personalizzati del tipo specificato a un membro specificato.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Indica se gli attributi personalizzati di un tipo specificato vengono applicati a un membro specificato e, facoltativamente, ai relativi predecessori.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Ottiene un token di metadati per il membro specificato, se disponibile.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Restituisce un valore che indica se un token di metadati è disponibile per il membro specificato.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

Recupera un oggetto che rappresenta il metodo specificato nella classe di base diretta o indiretta in cui il metodo è stato inizialmente dichiarato.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

Si applica a

Vedi anche