Module.ResolveMethod Método

  • Referencia

Definición

Espacio de nombres:
System.Reflection
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Devuelve el método identificado por un token de metadatos.

Sobrecargas

ResolveMethod(Int32, Type[], Type[])

Devuelve el método o constructor identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.
ResolveMethod(Int32)

Devuelve el método o constructor identificado por el token de metadatos especificado.

ResolveMethod(Int32, Type[], Type[])

Source:
Module.cs
Source:
Module.cs
Source:
Module.cs

Devuelve el método o constructor identificado por el token de metadatos especificado, en el contexto definido por los parámetros de tipo genérico especificados.

public:
 virtual System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);
public:
 System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);
public virtual System.Reflection.MethodBase? ResolveMethod (int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments);
public virtual System.Reflection.MethodBase ResolveMethod (int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
public System.Reflection.MethodBase ResolveMethod (int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
abstract member ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBase
override this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBase
member this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBase
Public Overridable Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBase
Public Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBase

Parámetros

metadataToken
Int32

Token de metadatos que identifica un método o constructor en el módulo.

genericTypeArguments
Type[]

Matriz de objetos Type que representan los argumentos de tipo genérico del tipo en cuyo ámbito se encuentra el token; o es null si dicho tipo no es genérico.

genericMethodArguments
Type[]

Matriz de objetos Type que representan los argumentos de tipo genérico del método en cuyo ámbito se encuentra el token; o es null si dicho método no es genérico.

Devoluciones

MethodBase

Objeto MethodBase que representa el método identificado por el token de metadatos especificado.

Excepciones

ArgumentException

metadataToken no es un token para un método o constructor en el ámbito del módulo actual.

o bien

metadataToken es un MethodSpec cuya firma contiene el tipo de elemento var (un parámetro de tipo de un tipo genérico) o mvar (un parámetro de tipo de un método genérico) y no se proporcionaron los argumentos de tipo genérico necesarios para uno o ambos parámetros genericTypeArguments y genericMethodArguments.

ArgumentOutOfRangeException

metadataToken no es un token válido en el ámbito del módulo actual.

Ejemplos

En el ejemplo siguiente se muestra cómo usar las dos sobrecargas del ResolveMethod método para resolver tokens de metadatos de sitios de llamada en contextos genéricos y no genéricos.

En el ejemplo de código se definen dos tipos genéricos, G1<Tg1> y G2<Tg2>, cada uno de los cuales tiene un método genérico. G1<Tg1> también tiene un método no genérico que usa el parámetro Tg1 de tipo para su parámetro. El método GM2<Tgm2> genérico del tipo G2<Tg2> contiene varias llamadas de método:

  • Caso 1: se llama al método GM1<Tgm1> genérico, utilizando los parámetros de tipo de G2<Tg2> y GM2<Tgm2> como argumentos de tipo. En otras palabras, los tipos de parámetros del método llamado dependerán de los tipos que se usan para construir un tipo genérico cerrado a partir de la definición de tipo para G2<Tg2>.

  • Caso 2: se llama al método M1 no genérico. El parámetro de este método usa el parámetro type del tipo que define, G1<Tg1>, que se reemplaza en este caso por el parámetro type del tipo envolvente, G2<Tg2>.

  • Caso 3: se llama al método GM1<Tgm1> genérico, especificando Int32 y Object para los argumentos de tipo del tipo genérico y el método genérico, respectivamente. Esta llamada al método no depende de los parámetros de tipo del tipo o método envolvente.

  • Caso 4: se llama al método M1 no genérico de la Example clase . Esta llamada al método no depende de los parámetros de tipo del tipo o método envolvente.

Además, en el ejemplo se define la clase no genérica Example . Esta clase tiene un método M que realiza una llamada a un método genérico.

  • Caso 5: se llama al método GM1<Tgm1> genérico, especificando Int32 y Object para los argumentos de tipo del tipo genérico y el método genérico, respectivamente. El contexto de este método no tiene ningún tipo genérico o método genérico envolvente.

Para cada caso, el ejemplo crea primero un MethodInfo objeto que representa el método llamado y, a continuación, resuelve el token mediante la sobrecarga del ResolveMethod(Int32, Type[], Type[]) método , utilizando los Type.GetGenericArguments métodos y MethodInfo.GetGenericArguments para obtener los valores de los genericTypeArguments parámetros y genericMethodArguments . Esta técnica funciona en todos los casos, porque los métodos devuelven Type.EmptyTypes para contextos no genéricos. En el ejemplo se compara el objeto resuelto MethodInfo con el construido MethodInfo.

A continuación, el ejemplo intenta usar la sobrecarga del ResolveMethod(Int32) método para resolver el token. Esto funciona en los casos 3, 4 y 5, porque las llamadas al método no dependen del contexto genérico. En los casos 1 y 2, se produce una excepción porque no hay suficiente información para resolver el token.

Los valores del token de metadatos se codifican de forma rígida como una enumeración. Si cambia este ejemplo de código, es probable que cambien los valores del token. Para determinar los nuevos valores de token, compile el código y use Ildasm.exe con la opción /TOKENS para examinar el ensamblado. Los tokens se pueden encontrar en los puntos de llamada. Inserte los nuevos valores en la enumeración y vuelva a compilar el ejemplo.

using System;
using System.Reflection;

namespace ResolveMethodExample
{
    // Metadata tokens for the MethodRefs that are to be resolved.
    // If you change this program, some or all of these metadata tokens might
    // change. The new token values can be discovered by compiling the example
    // and examining the assembly with Ildasm.exe, using the /TOKENS option.
    // Recompile the program after correcting the token values.
    enum Tokens
    {
        Case1 = 0x2b000001,
        Case2 = 0x0A000006,
        Case3 = 0x2b000002,
        Case4 = 0x06000006,
        Case5 = 0x2b000002
    }

    class G1<Tg1>
    {
        public void GM1<Tgm1> (Tg1 param1, Tgm1 param2) {}
        public void M1(Tg1 param) {}
    }

    class G2<Tg2>
    {
        public void GM2<Tgm2> (Tg2 param1, Tgm2 param2)
        {
            // Case 1: A generic method call that depends on its generic
            // context, because it uses the type parameters of the enclosing
            // generic type G2 and the enclosing generic method GM2. The token
            // for the MethodSpec is Tokens.Case1.
            G1<Tg2> g = new G1<Tg2>();
            g.GM1<Tgm2>(param1, param2);

            // Case 2: A non-generic method call that depends on its generic
            // context, because it uses the type parameter of the enclosing
            // generic type G2. The token for the MemberRef is Tokens.Case2.
            g.M1(param1);

            // Case 3: A generic method call that does not depend on its generic
            // context, because it does not use type parameters of the enclosing
            // generic type or method. The token for the MethodSpec is Tokens.Case3.
            G1<int> gi = new G1<int>();
            gi.GM1<object>(42, new Object());

            // Case 4: A non-generic method call that does not depend on its
            // generic context, because it does not use the type parameters of the
            // enclosing generic type or method. The token for the MethodDef is
            // Tokens.Case4.
            Example e = new Example();
            e.M();
        }
    }

    class Example
    {
        public void M()
        {
            G1<int> g = new G1<int>();
            // Case 5: A generic method call that does not have any generic
            // context. The token for the MethodSpec is Tokens.Case5.
            g.GM1<object>(42, new Object());
        }

        static void Main ()
        {
            Module mod = typeof(Example).Assembly.ManifestModule;
            MethodInfo miResolved2 = null;

            // Case 1: A generic method call that is dependent on its generic context.
            //
            // Create and display a MethodInfo representing the MethodSpec of the
            // generic method g.GM1<Tgm2>() that is called in G2<Tg2>.GM2<Tgm2>().
            Type t = typeof(G1<>).MakeGenericType(typeof(G2<>).GetGenericArguments());
            MethodInfo mi = typeof(G2<>).GetMethod("GM2");
            MethodInfo miTest = t.GetMethod("GM1").MakeGenericMethod(mi.GetGenericArguments());
            Console.WriteLine("\nCase 1:\n{0}", miTest);

            // Resolve the MethodSpec token for method G1<Tg2>.GM1<Tgm2>(), which
            // is called in method G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method
            // must be used to obtain the context for resolving the method.
            MethodInfo miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case1,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The overload that doesn't specify generic context throws an exception
            // because there is insufficient context to resolve the token.
            try
            {
                miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case1);
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message);
            }

            // Case 2: A non-generic method call that is dependent on its generic context.
            //
            // Create and display a MethodInfo representing the MemberRef of the
            // non-generic method g.M1() that is called in G2<Tg2>.GM2<Tgm2>().
            t = typeof(G1<>).MakeGenericType(typeof(G2<>).GetGenericArguments());
            miTest = t.GetMethod("M1");
            Console.WriteLine("\nCase 2:\n{0}", miTest);

            // Resolve the MemberRef token for method G1<Tg2>.M1(), which is
            // called in method G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method
            // must be used to obtain the context for resolving the method, because
            // the method parameter comes from the generic type G1, and the type
            // argument, Tg2, comes from the generic type that encloses the call.
            // There is no enclosing generic method, so the value Type.EmptyTypes
            // could be passed for the genericMethodArguments parameter.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case2,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The overload that doesn't specify generic context throws an exception
            // because there is insufficient context to resolve the token.
            try
            {
                miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case2);
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message);
            }

            // Case 3: A generic method call that is independent of its generic context.
            //
            // Create and display a MethodInfo representing the MethodSpec of the
            // generic method gi.GM1<object>() that is called in G2<Tg2>.GM2<Tgm2>().
            mi = typeof(G1<int>).GetMethod("GM1");
            miTest = mi.MakeGenericMethod(new Type[] { typeof(object) });
            Console.WriteLine("\nCase 3:\n{0}", miTest);

            // Resolve the token for method G1<int>.GM1<object>(), which is called
            // in G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the method call in
            // this case does not use type parameters of the enclosing type or
            // method, so Type.EmptyTypes could be used for both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case3,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on the enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case3);

            // Case 4: A non-generic method call that is independent of its generic context.
            //
            // Create and display a MethodInfo representing the MethodDef of the
            // method e.M() that is called in G2<Tg2>.GM2<Tgm2>().
            miTest = typeof(Example).GetMethod("M");
            Console.WriteLine("\nCase 4:\n{0}", miTest);

            // Resolve the token for method Example.M(), which is called in
            // G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the non-generic
            // method call does not use type parameters of the enclosing type or
            // method, so Type.EmptyTypes could be used for both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case4,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on any enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case4);

            // Case 5: Generic method call in a non-generic context.
            //
            // Create and display a MethodInfo representing the MethodRef of the
            // closed generic method g.GM1<object>() that is called in Example.M().
            mi = typeof(G1<int>).GetMethod("GM1");
            miTest = mi.MakeGenericMethod(new Type[] { typeof(object) });
            Console.WriteLine("\nCase 5:\n{0}", miTest);

            // Resolve the token for method G1<int>.GM1<object>(), which is called
            // in method Example.M(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the enclosing type
            // and method are not generic, so Type.EmptyTypes could be used for
            // both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case5,
                typeof(Example).GetGenericArguments(),
                typeof(Example).GetMethod("M").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on any enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case5);
        }
    }
}
/* This example produces the following output:

Case 1:
Void GM1[Tgm2](Tg2, Tgm2)
Void GM1[Tgm2](Tg2, Tgm2)
Is the resolved method the same? True
System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.

Case 2:
Void M1(Tg2)
Void M1(Tg2)
Is the resolved method the same? True
System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.

Case 3:
Void GM1[Object](Int32, System.Object)
Void GM1[Object](Int32, System.Object)
Is the resolved method the same? True

Case 4:
Void M()
Void M()
Is the resolved method the same? True

Case 5:
Void GM1[Object](Int32, System.Object)
Void GM1[Object](Int32, System.Object)
Is the resolved method the same? True
 */

Imports System.Reflection

Namespace ResolveMethodExample

    ' Metadata tokens for the MethodRefs that are to be resolved.
    ' If you change this program, some or all of these metadata tokens might
    ' change. The new token values can be discovered by compiling the example
    ' and examining the assembly with Ildasm.exe, using the /TOKENS option. 
    ' Recompile the program after correcting the token values. 
    Enum Tokens
        Case1 = &H2B000003
        Case2 = &HA00001F
        Case3 = &H2B000004
        Case4 = &H6000017
        Case5 = &H2B000004
    End Enum 


    Class G1(Of Tg1)

        Public Sub GM1(Of Tgm1) (ByVal param1 As Tg1, ByVal param2 As Tgm1)
        End Sub

        Public Sub M1(ByVal param As Tg1)
        End Sub
    End Class

    Class G2(Of Tg2)
    
        Public Sub GM2(Of Tgm2) (ByVal param1 As Tg2, ByVal param2 As Tgm2)
        
            ' Case 1: A generic method call that depends on its generic 
            ' context, because it uses the type parameters of the enclosing
            ' generic type G2 and the enclosing generic method GM2. The token 
            ' for the MethodSpec is Tokens.Case1.
            Dim g As New G1(Of Tg2)()
            g.GM1(Of Tgm2)(param1, param2)

            ' Case 2: A non-generic method call that depends on its generic 
            ' context, because it uses the type parameter of the enclosing
            ' generic type G2. The token for the MemberRef is Tokens.Case2.
            g.M1(param1)

            ' Case 3: A generic method call that does not depend on its generic 
            ' context, because it does not use type parameters of the enclosing
            ' generic type or method. The token for the MethodSpec is Tokens.Case3.
            Dim gi As New G1(Of Integer)()
            gi.GM1(Of Object)(42, New Object())

            ' Case 4: A non-generic method call that does not depend on its 
            ' generic context, because it does not use the type parameters of the
            ' enclosing generic type or method. The token for the MethodDef is 
            ' Tokens.Case4.
            Dim e As New Example()
            e.M()
        End Sub 
    End Class

    Class Example
        Public Sub M() 
            Dim g As New G1(Of Integer)()
            ' Case 5: A generic method call that does not have any generic 
            ' context. The token for the MethodSpec is Tokens.Case5.
            g.GM1(Of Object)(42, New Object())
        End Sub 
    
        Shared Sub Main() 
            Dim m As [Module] = GetType(Example).Assembly.ManifestModule
            Dim miResolved2 As MethodInfo = Nothing
        
            ' Case 1: A generic method call that is dependent on its generic context.
            '
            ' Create and display a MethodInfo representing the MethodSpec of the 
            ' generic method g.GM1(Of Tgm2)() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            Dim t As Type = GetType(G1(Of )).MakeGenericType(GetType(G2(Of )).GetGenericArguments())
            Dim mi As MethodInfo = GetType(G2(Of )).GetMethod("GM2")
            Dim miTest As MethodInfo = t.GetMethod("GM1").MakeGenericMethod(mi.GetGenericArguments())
            Console.WriteLine(vbCrLf & "Case 1:" & vbCrLf & miTest.ToString())
        
            ' Resolve the MethodSpec token for method G1(Of Tg2).GM1(Of Tgm2)(), which 
            ' is called in method G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments 
            ' method must be used to obtain the context for resolving the method.
            Dim miResolved As MethodInfo = CType(m.ResolveMethod( _
                    CInt(Tokens.Case1), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The overload that doesn't specify generic context throws an exception
            ' because there is insufficient context to resolve the token.
            Try
                miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case1)), MethodInfo)
            Catch ex As Exception
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message)
            End Try
        
        
            ' Case 2: A non-generic method call that is dependent on its generic context.
            '
            ' Create and display a MethodInfo representing the MemberRef of the 
            ' non-generic method g.M1() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            t = GetType(G1(Of )).MakeGenericType(GetType(G2(Of )).GetGenericArguments())
            miTest = t.GetMethod("M1")
            Console.WriteLine(vbCrLf & "Case 2:" & vbCrLf & miTest.ToString())
        
            ' Resolve the MemberRef token for method G1(Of Tg2).M1(), which is
            ' called in method G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments 
            ' method must be used to obtain the context for resolving the method, 
            ' because the method parameter comes from the generic type G1, and the 
            ' because argument, Tg2, comes from the generic type that encloses the 
            ' call. There is no enclosing generic method, so Type.EmptyTypes could
            ' be passed for the genericMethodArguments parameter.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case2), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The overload that doesn't specify generic context throws an exception
            ' because there is insufficient context to resolve the token.
            Try
                miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case2)), MethodInfo)
            Catch ex As Exception
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message)
            End Try
        
        
            ' Case 3: A generic method call that is independent of its generic context.
            '
            ' Create and display a MethodInfo representing the MethodSpec of the 
            ' generic method gi.GM1(Of Object)() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            mi = GetType(G1(Of Integer)).GetMethod("GM1")
            miTest = mi.MakeGenericMethod(New Type() {GetType(Object)})
            Console.WriteLine(vbCrLf & "Case 3:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method G1(Of Integer).GM1(Of Object)(), which is 
            ' calledin G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments method is  
            ' used to obtain the context for resolving the method, but the method call
            ' in this case does not use type parameters of the enclosing type or
            ' method, so Type.EmptyTypes could be used for both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case3), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on the enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case3)), MethodInfo)
        
        
            ' Case 4: A non-generic method call that is independent of its generic context.
            '
            ' Create and display a MethodInfo representing the MethodDef of the 
            ' method e.M() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            miTest = GetType(Example).GetMethod("M")
            Console.WriteLine(vbCrLf & "Case 4:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method Example.M(), which is called in
            ' G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments method is used to 
            ' obtain the context for resolving the method, but the non-generic 
            ' method call does not use type parameters of the enclosing type or
            ' method, so Type.EmptyTypes could be used for both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case4), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on any enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case4)), MethodInfo)
        
        
            ' Case 5: Generic method call in a non-generic context.
            '
            ' Create and display a MethodInfo representing the MethodRef of the 
            ' closed generic method g.GM1(Of Object)() that is called in Example.M().
            mi = GetType(G1(Of Integer)).GetMethod("GM1")
            miTest = mi.MakeGenericMethod(New Type() {GetType(Object)})
            Console.WriteLine(vbCrLf & "Case 5:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method G1(Of Integer).GM1(Of Object)(), which is 
            ' called in method Example.M(). The GetGenericArguments method is used to 
            ' obtain the context for resolving the method, but the enclosing type
            ' and method are not generic, so Type.EmptyTypes could be used for
            ' both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case5), _
                    GetType(Example).GetGenericArguments(), _
                    GetType(Example).GetMethod("M").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on any enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case5)), MethodInfo)
    
        End Sub 
    End Class 
End Namespace

' This example produces the following output:
'
'Case 1:
'Void GM1[Tgm2](Tg2, Tgm2)
'Void GM1[Tgm2](Tg2, Tgm2)
'Is the resolved method the same? True
'System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.
'
'Case 2:
'Void M1(Tg2)
'Void M1(Tg2)
'Is the resolved method the same? True
'System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.
'
'Case 3:
'Void GM1[Object](Int32, System.Object)
'Void GM1[Object](Int32, System.Object)
'Is the resolved method the same? True
'
'Case 4:
'Void M()
'Void M()
'Is the resolved method the same? True
'
'Case 5:
'Void GM1[Object](Int32, System.Object)
'Void GM1[Object](Int32, System.Object)
'Is the resolved method the same? True
'

Comentarios

Use el Type.GetGenericArguments método en el tipo donde metadataToken está en el ámbito para obtener una matriz de argumentos de tipo genérico para genericTypeArguments. Use el MethodInfo.GetGenericArguments método en el método donde metadataToken está en el ámbito para obtener una matriz de argumentos de tipo genérico para genericMethodArguments. Siempre es seguro proporcionar estos argumentos, incluso cuando no son necesarios.

Nota

Puede encontrar información sobre los tokens de metadatos en la documentación de Common Language Infrastructure (CLI), especialmente "Partición II: Definición de metadatos y Semántica". Para obtener más información, consulte ECMA 335 Common Language Infrastructure (CLI).

Se aplica a

ResolveMethod(Int32)

Source:
Module.cs
Source:
Module.cs
Source:
Module.cs

Devuelve el método o constructor identificado por el token de metadatos especificado.

public:
 System::Reflection::MethodBase ^ ResolveMethod(int metadataToken);
public System.Reflection.MethodBase? ResolveMethod (int metadataToken);
public System.Reflection.MethodBase ResolveMethod (int metadataToken);
member this.ResolveMethod : int -> System.Reflection.MethodBase
Public Function ResolveMethod (metadataToken As Integer) As MethodBase

Parámetros

metadataToken
Int32

Token de metadatos que identifica un método o constructor en el módulo.

Devoluciones

MethodBase

Objeto MethodBase que representa el método o constructor identificado por el token de metadatos especificado.

Excepciones

ArgumentException

metadataToken no es un token para un método o constructor en el ámbito del módulo actual.

o bien

metadataToken es un MethodSpec cuya firma contiene el tipo de elemento var (un parámetro de tipo de un tipo genérico) o mvar (un parámetro de tipo de un método genérico).

ArgumentOutOfRangeException

metadataToken no es un token válido en el ámbito del módulo actual.

Ejemplos

En el ejemplo siguiente se muestra cómo usar las dos sobrecargas del ResolveMethod método para resolver tokens de metadatos de sitios de llamada en contextos genéricos y no genéricos.

En el ejemplo de código se definen dos tipos genéricos, G1<Tg1> y G2<Tg2> (G1(Of Tg1) y G2(Of Tg2) en Visual Basic), cada uno de los cuales tiene un método genérico. G1<Tg1> también tiene un método no genérico que usa el parámetro Tg1 de tipo para su parámetro. El método GM2<Tgm2> genérico del tipo G2<Tg2> contiene varias llamadas de método:

  • Caso 1: se llama al método GM1<Tgm1> genérico, utilizando los parámetros de tipo de G2<Tg2> y GM2<Tgm2> como argumentos de tipo. En otras palabras, los tipos de parámetros del método llamado dependerán de los tipos que se usan para construir un tipo genérico cerrado a partir de la definición de tipo para G2<Tg2>.

  • Caso 2: se llama al método M1 no genérico. El parámetro de este método usa el parámetro type del tipo que define, G1<Tg1>, que se reemplaza en este caso por el parámetro type del tipo envolvente, G2<Tg2>.

  • Caso 3: se llama al método GM1<Tgm1> genérico, especificando Int32 y Object para los argumentos de tipo del tipo genérico y el método genérico, respectivamente. Esta llamada al método no depende de los parámetros de tipo del tipo o método envolvente.

  • Caso 4: se llama al método M1 no genérico de la Example clase . Esta llamada al método no depende de los parámetros de tipo del tipo o método envolvente.

Además, en el ejemplo se define la clase no genérica Example . Esta clase tiene un método M que realiza una llamada a un método genérico:

  • Caso 5: se llama al método GM1 genérico, especificando Int32 y Object para los argumentos de tipo del tipo genérico y el método genérico, respectivamente. El contexto de este método no tiene ningún tipo genérico o método genérico envolvente.

Para cada caso, el ejemplo crea primero un MethodInfo objeto que representa el método llamado y, a continuación, resuelve el token mediante la sobrecarga del ResolveMethod(Int32, Type[], Type[]) método , utilizando los Type.GetGenericArguments métodos y MethodInfo.GetGenericArguments para obtener los valores de los genericTypeArguments parámetros y genericMethodArguments . Esta técnica funciona en todos los casos, porque los métodos devuelven Type.EmptyTypes para contextos no genéricos. En el ejemplo se compara el objeto resuelto MethodInfo con el construido MethodInfo.

A continuación, el ejemplo intenta usar la sobrecarga del ResolveMethod(Int32) método para resolver el token. Esto funciona en los casos 3, 4 y 5, porque las llamadas al método no dependen del contexto genérico. En los casos 1 y 2, se produce una excepción porque no hay suficiente información para resolver el token.

Los valores del token de metadatos se codifican de forma rígida como una enumeración. Si cambia este ejemplo de código, es probable que cambien los valores del token. Para determinar los nuevos valores de token, compile el código y use Ildasm.exe con la opción /TOKENS para examinar el ensamblado. Los tokens se pueden encontrar en los puntos de llamada. Inserte los nuevos valores en la enumeración y vuelva a compilar el ejemplo.

using System;
using System.Reflection;

namespace ResolveMethodExample
{
    // Metadata tokens for the MethodRefs that are to be resolved.
    // If you change this program, some or all of these metadata tokens might
    // change. The new token values can be discovered by compiling the example
    // and examining the assembly with Ildasm.exe, using the /TOKENS option.
    // Recompile the program after correcting the token values.
    enum Tokens
    {
        Case1 = 0x2b000001,
        Case2 = 0x0A000006,
        Case3 = 0x2b000002,
        Case4 = 0x06000006,
        Case5 = 0x2b000002
    }

    class G1<Tg1>
    {
        public void GM1<Tgm1> (Tg1 param1, Tgm1 param2) {}
        public void M1(Tg1 param) {}
    }

    class G2<Tg2>
    {
        public void GM2<Tgm2> (Tg2 param1, Tgm2 param2)
        {
            // Case 1: A generic method call that depends on its generic
            // context, because it uses the type parameters of the enclosing
            // generic type G2 and the enclosing generic method GM2. The token
            // for the MethodSpec is Tokens.Case1.
            G1<Tg2> g = new G1<Tg2>();
            g.GM1<Tgm2>(param1, param2);

            // Case 2: A non-generic method call that depends on its generic
            // context, because it uses the type parameter of the enclosing
            // generic type G2. The token for the MemberRef is Tokens.Case2.
            g.M1(param1);

            // Case 3: A generic method call that does not depend on its generic
            // context, because it does not use type parameters of the enclosing
            // generic type or method. The token for the MethodSpec is Tokens.Case3.
            G1<int> gi = new G1<int>();
            gi.GM1<object>(42, new Object());

            // Case 4: A non-generic method call that does not depend on its
            // generic context, because it does not use the type parameters of the
            // enclosing generic type or method. The token for the MethodDef is
            // Tokens.Case4.
            Example e = new Example();
            e.M();
        }
    }

    class Example
    {
        public void M()
        {
            G1<int> g = new G1<int>();
            // Case 5: A generic method call that does not have any generic
            // context. The token for the MethodSpec is Tokens.Case5.
            g.GM1<object>(42, new Object());
        }

        static void Main ()
        {
            Module mod = typeof(Example).Assembly.ManifestModule;
            MethodInfo miResolved2 = null;

            // Case 1: A generic method call that is dependent on its generic context.
            //
            // Create and display a MethodInfo representing the MethodSpec of the
            // generic method g.GM1<Tgm2>() that is called in G2<Tg2>.GM2<Tgm2>().
            Type t = typeof(G1<>).MakeGenericType(typeof(G2<>).GetGenericArguments());
            MethodInfo mi = typeof(G2<>).GetMethod("GM2");
            MethodInfo miTest = t.GetMethod("GM1").MakeGenericMethod(mi.GetGenericArguments());
            Console.WriteLine("\nCase 1:\n{0}", miTest);

            // Resolve the MethodSpec token for method G1<Tg2>.GM1<Tgm2>(), which
            // is called in method G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method
            // must be used to obtain the context for resolving the method.
            MethodInfo miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case1,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The overload that doesn't specify generic context throws an exception
            // because there is insufficient context to resolve the token.
            try
            {
                miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case1);
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message);
            }

            // Case 2: A non-generic method call that is dependent on its generic context.
            //
            // Create and display a MethodInfo representing the MemberRef of the
            // non-generic method g.M1() that is called in G2<Tg2>.GM2<Tgm2>().
            t = typeof(G1<>).MakeGenericType(typeof(G2<>).GetGenericArguments());
            miTest = t.GetMethod("M1");
            Console.WriteLine("\nCase 2:\n{0}", miTest);

            // Resolve the MemberRef token for method G1<Tg2>.M1(), which is
            // called in method G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method
            // must be used to obtain the context for resolving the method, because
            // the method parameter comes from the generic type G1, and the type
            // argument, Tg2, comes from the generic type that encloses the call.
            // There is no enclosing generic method, so the value Type.EmptyTypes
            // could be passed for the genericMethodArguments parameter.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case2,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The overload that doesn't specify generic context throws an exception
            // because there is insufficient context to resolve the token.
            try
            {
                miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case2);
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message);
            }

            // Case 3: A generic method call that is independent of its generic context.
            //
            // Create and display a MethodInfo representing the MethodSpec of the
            // generic method gi.GM1<object>() that is called in G2<Tg2>.GM2<Tgm2>().
            mi = typeof(G1<int>).GetMethod("GM1");
            miTest = mi.MakeGenericMethod(new Type[] { typeof(object) });
            Console.WriteLine("\nCase 3:\n{0}", miTest);

            // Resolve the token for method G1<int>.GM1<object>(), which is called
            // in G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the method call in
            // this case does not use type parameters of the enclosing type or
            // method, so Type.EmptyTypes could be used for both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case3,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on the enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case3);

            // Case 4: A non-generic method call that is independent of its generic context.
            //
            // Create and display a MethodInfo representing the MethodDef of the
            // method e.M() that is called in G2<Tg2>.GM2<Tgm2>().
            miTest = typeof(Example).GetMethod("M");
            Console.WriteLine("\nCase 4:\n{0}", miTest);

            // Resolve the token for method Example.M(), which is called in
            // G2<Tg2>.GM2<Tgm2>(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the non-generic
            // method call does not use type parameters of the enclosing type or
            // method, so Type.EmptyTypes could be used for both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case4,
                typeof(G2<>).GetGenericArguments(),
                typeof(G2<>).GetMethod("GM2").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on any enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case4);

            // Case 5: Generic method call in a non-generic context.
            //
            // Create and display a MethodInfo representing the MethodRef of the
            // closed generic method g.GM1<object>() that is called in Example.M().
            mi = typeof(G1<int>).GetMethod("GM1");
            miTest = mi.MakeGenericMethod(new Type[] { typeof(object) });
            Console.WriteLine("\nCase 5:\n{0}", miTest);

            // Resolve the token for method G1<int>.GM1<object>(), which is called
            // in method Example.M(). The GetGenericArguments method is used to
            // obtain the context for resolving the method, but the enclosing type
            // and method are not generic, so Type.EmptyTypes could be used for
            // both arguments.
            miResolved = (MethodInfo) mod.ResolveMethod(
                (int)Tokens.Case5,
                typeof(Example).GetGenericArguments(),
                typeof(Example).GetMethod("M").GetGenericArguments());
            Console.WriteLine(miResolved);
            Console.WriteLine("Is the resolved method the same? {0}", miResolved == miTest);

            // The method call in this case does not depend on any enclosing generic
            // context, so the token can also be resolved by the simpler overload.
            miResolved2 = (MethodInfo) mod.ResolveMethod((int)Tokens.Case5);
        }
    }
}
/* This example produces the following output:

Case 1:
Void GM1[Tgm2](Tg2, Tgm2)
Void GM1[Tgm2](Tg2, Tgm2)
Is the resolved method the same? True
System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.

Case 2:
Void M1(Tg2)
Void M1(Tg2)
Is the resolved method the same? True
System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.

Case 3:
Void GM1[Object](Int32, System.Object)
Void GM1[Object](Int32, System.Object)
Is the resolved method the same? True

Case 4:
Void M()
Void M()
Is the resolved method the same? True

Case 5:
Void GM1[Object](Int32, System.Object)
Void GM1[Object](Int32, System.Object)
Is the resolved method the same? True
 */

Imports System.Reflection

Namespace ResolveMethodExample

    ' Metadata tokens for the MethodRefs that are to be resolved.
    ' If you change this program, some or all of these metadata tokens might
    ' change. The new token values can be discovered by compiling the example
    ' and examining the assembly with Ildasm.exe, using the /TOKENS option. 
    ' Recompile the program after correcting the token values. 
    Enum Tokens
        Case1 = &H2B000003
        Case2 = &HA00001F
        Case3 = &H2B000004
        Case4 = &H6000017
        Case5 = &H2B000004
    End Enum 


    Class G1(Of Tg1)

        Public Sub GM1(Of Tgm1) (ByVal param1 As Tg1, ByVal param2 As Tgm1)
        End Sub

        Public Sub M1(ByVal param As Tg1)
        End Sub
    End Class

    Class G2(Of Tg2)
    
        Public Sub GM2(Of Tgm2) (ByVal param1 As Tg2, ByVal param2 As Tgm2)
        
            ' Case 1: A generic method call that depends on its generic 
            ' context, because it uses the type parameters of the enclosing
            ' generic type G2 and the enclosing generic method GM2. The token 
            ' for the MethodSpec is Tokens.Case1.
            Dim g As New G1(Of Tg2)()
            g.GM1(Of Tgm2)(param1, param2)

            ' Case 2: A non-generic method call that depends on its generic 
            ' context, because it uses the type parameter of the enclosing
            ' generic type G2. The token for the MemberRef is Tokens.Case2.
            g.M1(param1)

            ' Case 3: A generic method call that does not depend on its generic 
            ' context, because it does not use type parameters of the enclosing
            ' generic type or method. The token for the MethodSpec is Tokens.Case3.
            Dim gi As New G1(Of Integer)()
            gi.GM1(Of Object)(42, New Object())

            ' Case 4: A non-generic method call that does not depend on its 
            ' generic context, because it does not use the type parameters of the
            ' enclosing generic type or method. The token for the MethodDef is 
            ' Tokens.Case4.
            Dim e As New Example()
            e.M()
        End Sub 
    End Class

    Class Example
        Public Sub M() 
            Dim g As New G1(Of Integer)()
            ' Case 5: A generic method call that does not have any generic 
            ' context. The token for the MethodSpec is Tokens.Case5.
            g.GM1(Of Object)(42, New Object())
        End Sub 
    
        Shared Sub Main() 
            Dim m As [Module] = GetType(Example).Assembly.ManifestModule
            Dim miResolved2 As MethodInfo = Nothing
        
            ' Case 1: A generic method call that is dependent on its generic context.
            '
            ' Create and display a MethodInfo representing the MethodSpec of the 
            ' generic method g.GM1(Of Tgm2)() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            Dim t As Type = GetType(G1(Of )).MakeGenericType(GetType(G2(Of )).GetGenericArguments())
            Dim mi As MethodInfo = GetType(G2(Of )).GetMethod("GM2")
            Dim miTest As MethodInfo = t.GetMethod("GM1").MakeGenericMethod(mi.GetGenericArguments())
            Console.WriteLine(vbCrLf & "Case 1:" & vbCrLf & miTest.ToString())
        
            ' Resolve the MethodSpec token for method G1(Of Tg2).GM1(Of Tgm2)(), which 
            ' is called in method G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments 
            ' method must be used to obtain the context for resolving the method.
            Dim miResolved As MethodInfo = CType(m.ResolveMethod( _
                    CInt(Tokens.Case1), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The overload that doesn't specify generic context throws an exception
            ' because there is insufficient context to resolve the token.
            Try
                miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case1)), MethodInfo)
            Catch ex As Exception
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message)
            End Try
        
        
            ' Case 2: A non-generic method call that is dependent on its generic context.
            '
            ' Create and display a MethodInfo representing the MemberRef of the 
            ' non-generic method g.M1() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            t = GetType(G1(Of )).MakeGenericType(GetType(G2(Of )).GetGenericArguments())
            miTest = t.GetMethod("M1")
            Console.WriteLine(vbCrLf & "Case 2:" & vbCrLf & miTest.ToString())
        
            ' Resolve the MemberRef token for method G1(Of Tg2).M1(), which is
            ' called in method G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments 
            ' method must be used to obtain the context for resolving the method, 
            ' because the method parameter comes from the generic type G1, and the 
            ' because argument, Tg2, comes from the generic type that encloses the 
            ' call. There is no enclosing generic method, so Type.EmptyTypes could
            ' be passed for the genericMethodArguments parameter.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case2), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The overload that doesn't specify generic context throws an exception
            ' because there is insufficient context to resolve the token.
            Try
                miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case2)), MethodInfo)
            Catch ex As Exception
                Console.WriteLine("{0}: {1}", ex.GetType(), ex.Message)
            End Try
        
        
            ' Case 3: A generic method call that is independent of its generic context.
            '
            ' Create and display a MethodInfo representing the MethodSpec of the 
            ' generic method gi.GM1(Of Object)() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            mi = GetType(G1(Of Integer)).GetMethod("GM1")
            miTest = mi.MakeGenericMethod(New Type() {GetType(Object)})
            Console.WriteLine(vbCrLf & "Case 3:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method G1(Of Integer).GM1(Of Object)(), which is 
            ' calledin G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments method is  
            ' used to obtain the context for resolving the method, but the method call
            ' in this case does not use type parameters of the enclosing type or
            ' method, so Type.EmptyTypes could be used for both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case3), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on the enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case3)), MethodInfo)
        
        
            ' Case 4: A non-generic method call that is independent of its generic context.
            '
            ' Create and display a MethodInfo representing the MethodDef of the 
            ' method e.M() that is called in G2(Of Tg2).GM2(Of Tgm2)().
            miTest = GetType(Example).GetMethod("M")
            Console.WriteLine(vbCrLf & "Case 4:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method Example.M(), which is called in
            ' G2(Of Tg2).GM2(Of Tgm2)(). The GetGenericArguments method is used to 
            ' obtain the context for resolving the method, but the non-generic 
            ' method call does not use type parameters of the enclosing type or
            ' method, so Type.EmptyTypes could be used for both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case4), _
                    GetType(G2(Of )).GetGenericArguments(), _
                    GetType(G2(Of )).GetMethod("GM2").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on any enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case4)), MethodInfo)
        
        
            ' Case 5: Generic method call in a non-generic context.
            '
            ' Create and display a MethodInfo representing the MethodRef of the 
            ' closed generic method g.GM1(Of Object)() that is called in Example.M().
            mi = GetType(G1(Of Integer)).GetMethod("GM1")
            miTest = mi.MakeGenericMethod(New Type() {GetType(Object)})
            Console.WriteLine(vbCrLf & "Case 5:" & vbCrLf & miTest.ToString())
        
            ' Resolve the token for method G1(Of Integer).GM1(Of Object)(), which is 
            ' called in method Example.M(). The GetGenericArguments method is used to 
            ' obtain the context for resolving the method, but the enclosing type
            ' and method are not generic, so Type.EmptyTypes could be used for
            ' both arguments.
            miResolved = CType(m.ResolveMethod( _
                    CInt(Tokens.Case5), _
                    GetType(Example).GetGenericArguments(), _
                    GetType(Example).GetMethod("M").GetGenericArguments()), _
                MethodInfo)
            Console.WriteLine(miResolved)
            Console.WriteLine("Is the resolved method the same? {0}", miResolved Is miTest)
        
            ' The method call in this case does not depend on any enclosing generic
            ' context, so the token can also be resolved by the simpler overload.
            miResolved2 = CType(m.ResolveMethod(CInt(Tokens.Case5)), MethodInfo)
    
        End Sub 
    End Class 
End Namespace

' This example produces the following output:
'
'Case 1:
'Void GM1[Tgm2](Tg2, Tgm2)
'Void GM1[Tgm2](Tg2, Tgm2)
'Is the resolved method the same? True
'System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.
'
'Case 2:
'Void M1(Tg2)
'Void M1(Tg2)
'Is the resolved method the same? True
'System.ArgumentException: A BadImageFormatException has been thrown while parsing the signature. This is likely due to lack of a generic context. Ensure genericTypeArguments and genericMethodArguments are provided and contain enough context.
'
'Case 3:
'Void GM1[Object](Int32, System.Object)
'Void GM1[Object](Int32, System.Object)
'Is the resolved method the same? True
'
'Case 4:
'Void M()
'Void M()
'Is the resolved method the same? True
'
'Case 5:
'Void GM1[Object](Int32, System.Object)
'Void GM1[Object](Int32, System.Object)
'Is the resolved method the same? True
'

Comentarios

Para resolver un token de metadatos para una MethodSpec cuya firma contiene el tipo ELEMENT_TYPE_VAR de elemento o ELEMENT_TYPE_MVAR, use la sobrecarga de ResolveMethod(Int32, Type[], Type[]) método, lo que le permite proporcionar el contexto necesario. Es decir, cuando se resuelve un token de metadatos para un método que depende de los parámetros de tipo genérico del tipo genérico o del método genérico en el que se inserta el token, debe usar la sobrecarga que le permite proporcionar esos parámetros de tipo.

Nota

Puede encontrar información sobre los tokens de metadatos en la documentación de Common Language Infrastructure (CLI), especialmente "Partición II: Definición de metadatos y Semántica". Para obtener más información, consulte ECMA 335 Common Language Infrastructure (CLI).

Se aplica a