Module.ResolveMethod Methode
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Retourneert de methode die wordt geïdentificeerd door een metagegevenstoken.
Overloads
| Name | Description |
|---|---|
| ResolveMethod(Int32, Type[], Type[]) |
Retourneert de methode of constructor die is geïdentificeerd door het opgegeven metagegevenstoken, in de context die is gedefinieerd door de opgegeven algemene typeparameters. |
| ResolveMethod(Int32) |
Retourneert de methode of constructor die is geïdentificeerd door het opgegeven metagegevenstoken. |
ResolveMethod(Int32, Type[], Type[])
Retourneert de methode of constructor die is geïdentificeerd door het opgegeven metagegevenstoken, in de context die is gedefinieerd door de opgegeven algemene typeparameters.
public:
System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);public:
virtual System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);public System.Reflection.MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);public virtual System.Reflection.MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);member this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBaseabstract member ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBase
override this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBasePublic Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBasePublic Overridable Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBaseParameters
- metadataToken
- Int32
Een metagegevenstoken waarmee een methode of constructor in de module wordt geïdentificeerd.
- genericTypeArguments
- Type[]
Een matrix met Type objecten die de algemene typeargumenten van het type vertegenwoordigen van het type waarin het token zich binnen het bereik bevindt of null als dat type niet algemeen is.
- genericMethodArguments
- Type[]
Een matrix van Type objecten die de algemene typeargumenten van de methode vertegenwoordigen waar het token zich binnen het bereik bevindt of null als die methode niet algemeen is.
Retouren
Een MethodBase object dat de methode vertegenwoordigt die wordt geïdentificeerd door het opgegeven metagegevenstoken.
Uitzonderingen
metadataToken is geen token voor een methode of constructor binnen het bereik van de huidige module.
– of –
metadataToken is een MethodSpec wiens handtekening elementtype var bevat (een typeparameter van een algemeen type) of mvar (een typeparameter van een algemene methode) en de benodigde algemene typeargumenten zijn niet opgegeven voor of beide genericTypeArguments en genericMethodArguments.
metadataToken is geen geldig token binnen het bereik van de huidige module.
Voorbeelden
In het volgende voorbeeld ziet u hoe u de twee overbelastingen van de ResolveMethod methode gebruikt om metagegevenstokens op te lossen van oproepsites in algemene en niet-algemene contexten.
In het codevoorbeeld worden twee algemene typen gedefinieerd. G1<Tg1>G2<Tg2>Elk type heeft een algemene methode.
G1<Tg1> heeft ook een niet-algemene methode die gebruikmaakt van de typeparameter Tg1 voor de parameter. De algemene methode GM2<Tgm2> in het type G2<Tg2> bevat verschillende methode-aanroepen:
Case 1: De algemene methode
GM1<Tgm1>wordt aangeroepen, met behulp van de typeparameters vanG2<Tg2>enGM2<Tgm2>als de typeargumenten. Met andere woorden, de parametertypen van de aangeroepen methode zijn afhankelijk van de typen die worden gebruikt om een gesloten algemeen type te maken van de typedefinitie voorG2<Tg2>.Case 2: De niet-generieke methode
M1wordt aangeroepen. De parameter van deze methode maakt gebruik van de typeparameter van het definiërende type,G1<Tg1>die in dit geval wordt vervangen door de typeparameter van het insluittype,G2<Tg2>.Case 3: De algemene methode
GM1<Tgm1>wordt aangeroepen, waarbij respectievelijk Object de typeargumenten van het algemene type en de algemene methode worden opgegevenInt32. Deze methode-aanroep is niet afhankelijk van de typeparameters van het omsluittype of de methode.Case 4: De niet-generieke methode
M1van deExampleklasse wordt aangeroepen. Deze methode-aanroep is niet afhankelijk van de typeparameters van het omsluittype of de methode.
Daarnaast definieert het voorbeeld de niet-generieke Example klasse. Deze klasse heeft een methode M die een aanroep naar een algemene methode maakt.
- Case 5: De algemene methode
GM1<Tgm1>wordt aangeroepen, waarbij respectievelijk Object de typeargumenten van het algemene type en de algemene methode worden opgegevenInt32. De context voor deze methode bevat geen algemene type of algemene methode.
In elk geval maakt het voorbeeld eerst een MethodInfo methode die de aangeroepen methode vertegenwoordigt en vervolgens het token oplost met behulp van de overbelasting van de ResolveMethod(Int32, Type[], Type[]) methode, met behulp van de Type.GetGenericArguments en MethodInfo.GetGenericArguments methoden om de waarden voor de genericTypeArguments en genericMethodArguments parameters op te halen. Deze techniek werkt in alle gevallen, omdat de methoden worden geretourneerd Type.EmptyTypes voor niet-algemene contexten. In het voorbeeld wordt de opgeloste MethodInfo vergelijking vergeleken met de samengestelde MethodInfo.
In het voorbeeld wordt vervolgens geprobeerd de overbelasting van de ResolveMethod(Int32) methode te gebruiken om het token op te lossen. Dit werkt in gevallen 3, 4 en 5, omdat de methode-aanroepen niet afhankelijk zijn van de algemene context. In gevallen 1 en 2 wordt een uitzondering gegenereerd omdat er onvoldoende informatie is om het token op te lossen.
De metagegevenstokenwaarden zijn vastgelegd als opsomming. Als u dit codevoorbeeld wijzigt, worden de tokenwaarden waarschijnlijk gewijzigd. Als u de nieuwe tokenwaarden wilt bepalen, compileert u de code en gebruikt u Ildasm.exe met de optie /TOKENS om de assembly te onderzoeken. De tokens zijn te vinden op de aanroeppunten. Voeg de nieuwe waarden in de opsomming in en compileer het voorbeeld opnieuw.
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
'
Opmerkingen
Gebruik de Type.GetGenericArguments methode voor het type waar metadataToken zich binnen het bereik bevindt om een matrix met algemene typeargumenten voor genericTypeArgumentste verkrijgen. Gebruik de MethodInfo.GetGenericArguments methode voor de methode waar metadataToken zich binnen het bereik bevindt om een matrix met algemene typeargumenten voor genericMethodArgumentste verkrijgen. Het is altijd veilig om deze argumenten op te geven, zelfs wanneer ze niet nodig zijn.
Note
Informatie over metagegevenstokens vindt u in de DOCUMENTATIE van Common Language Infrastructure (CLI), met name Partition II: Metadata Definition and Semantics. Zie ECMA 335 Common Language Infrastructure (CLI) voor meer informatie.
Van toepassing op
ResolveMethod(Int32)
Retourneert de methode of constructor die is geïdentificeerd door het opgegeven metagegevenstoken.
public:
System::Reflection::MethodBase ^ ResolveMethod(int metadataToken);public System.Reflection.MethodBase ResolveMethod(int metadataToken);member this.ResolveMethod : int -> System.Reflection.MethodBasePublic Function ResolveMethod (metadataToken As Integer) As MethodBaseParameters
- metadataToken
- Int32
Een metagegevenstoken waarmee een methode of constructor in de module wordt geïdentificeerd.
Retouren
Een MethodBase object dat de methode of constructor vertegenwoordigt die wordt geïdentificeerd door het opgegeven metagegevenstoken.
Uitzonderingen
metadataToken is geen token voor een methode of constructor binnen het bereik van de huidige module.
– of –
metadataToken is een MethodSpec wiens handtekening elementtype var bevat (een typeparameter van een algemeen type) of mvar (een typeparameter van een algemene methode).
metadataToken is geen geldig token binnen het bereik van de huidige module.
Voorbeelden
In het volgende voorbeeld ziet u hoe u de twee overbelastingen van de ResolveMethod methode gebruikt om metagegevenstokens op te lossen van oproepsites in algemene en niet-algemene contexten.
In het codevoorbeeld worden twee algemene typen gedefinieerd: G1<Tg1> en G2<Tg2> (G1(Of Tg1) en G2(Of Tg2) in Visual Basic), die elk een algemene methode hebben.
G1<Tg1> heeft ook een niet-algemene methode die gebruikmaakt van de typeparameter Tg1 voor de parameter. De algemene methode GM2<Tgm2> in het type G2<Tg2> bevat verschillende methode-aanroepen:
Case 1: De algemene methode
GM1<Tgm1>wordt aangeroepen, met behulp van de typeparameters vanG2<Tg2>enGM2<Tgm2>als de typeargumenten. Met andere woorden, de parametertypen van de aangeroepen methode zijn afhankelijk van de typen die worden gebruikt om een gesloten algemeen type te maken van de typedefinitie voorG2<Tg2>.Case 2: De niet-generieke methode
M1wordt aangeroepen. De parameter van deze methode maakt gebruik van de typeparameter van het definiërende type,G1<Tg1>die in dit geval wordt vervangen door de typeparameter van het insluittype,G2<Tg2>.Case 3: De algemene methode
GM1<Tgm1>wordt aangeroepen, waarbij respectievelijk Object de typeargumenten van het algemene type en de algemene methode worden opgegevenInt32. Deze methode-aanroep is niet afhankelijk van de typeparameters van het omsluittype of de methode.Case 4: De niet-generieke methode
M1van deExampleklasse wordt aangeroepen. Deze methode-aanroep is niet afhankelijk van de typeparameters van het omsluittype of de methode.
Daarnaast definieert het voorbeeld de niet-generieke Example klasse. Deze klasse heeft een methode M die een aanroep naar een algemene methode maakt:
- Case 5: De algemene methode
GM1wordt aangeroepen, waarbij respectievelijk Object de typeargumenten van het algemene type en de algemene methode worden opgegevenInt32. De context voor deze methode bevat geen algemene type of algemene methode.
In elk geval maakt het voorbeeld eerst een MethodInfo methode die de aangeroepen methode vertegenwoordigt en vervolgens het token oplost met behulp van de overbelasting van de ResolveMethod(Int32, Type[], Type[]) methode, met behulp van de Type.GetGenericArguments en MethodInfo.GetGenericArguments methoden om de waarden voor de genericTypeArguments en genericMethodArguments parameters op te halen. Deze techniek werkt in alle gevallen, omdat de methoden worden geretourneerd Type.EmptyTypes voor niet-algemene contexten. In het voorbeeld wordt de opgeloste MethodInfo vergelijking vergeleken met de samengestelde MethodInfo.
In het voorbeeld wordt vervolgens geprobeerd de overbelasting van de ResolveMethod(Int32) methode te gebruiken om het token op te lossen. Dit werkt in gevallen 3, 4 en 5, omdat de methode-aanroepen niet afhankelijk zijn van de algemene context. In gevallen 1 en 2 wordt een uitzondering gegenereerd omdat er onvoldoende informatie is om het token op te lossen.
De metagegevenstokenwaarden zijn vastgelegd als opsomming. Als u dit codevoorbeeld wijzigt, worden de tokenwaarden waarschijnlijk gewijzigd. Als u de nieuwe tokenwaarden wilt bepalen, compileert u de code en gebruikt u Ildasm.exe met de optie /TOKENS om de assembly te onderzoeken. De tokens zijn te vinden op de aanroeppunten. Voeg de nieuwe waarden in de opsomming in en compileer het voorbeeld opnieuw.
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
'
Opmerkingen
Als u een metagegevenstoken wilt oplossen voor een MethodSpec handtekening met elementtype ELEMENT_TYPE_VAR of ELEMENT_TYPE_MVAR, gebruikt u de overbelasting van de ResolveMethod(Int32, Type[], Type[]) methode, zodat u de benodigde context kunt opgeven. Als u een metagegevenstoken voor een methode oplost die afhankelijk is van de algemene typeparameters van het algemene type en/of de algemene methode waarin het token is ingesloten, moet u de overbelasting gebruiken waarmee u deze typeparameters kunt opgeven.
Note
Informatie over metagegevenstokens vindt u in de DOCUMENTATIE van Common Language Infrastructure (CLI), met name Partition II: Metadata Definition and Semantics. Zie ECMA 335 Common Language Infrastructure (CLI) voor meer informatie.