Module.ResolveMethod 方法
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。
回傳由元資料標記所識別的方法。
多載
| 名稱 | Description |
|---|---|
| ResolveMethod(Int32, Type[], Type[]) |
回傳由指定中繼資料標記所識別的方法或建構子，並依指定泛型參數定義的上下文。 |
| ResolveMethod(Int32) |
回傳由指定中繼資料標記所識別的方法或建構子。 |
ResolveMethod(Int32, Type[], Type[])
回傳由指定中繼資料標記所識別的方法或建構子，並依指定泛型參數定義的上下文。
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 MethodBase參數
- metadataToken
- Int32
一個用來識別模組中方法或建構子的元資料標記。
傳回
一個 MethodBase 代表由指定元資料標記識別的方法的物件。
例外狀況
metadataToken 在當前模組的作用域中，並非方法或建構子的標記。
-或者-
metadataToken是 MethodSpec 其簽名包含元素型別var（泛型型別的型別參數）或mvar（泛型方法的型別參數），且未提供所需的通用型別參數，且未為其中任一或兩者genericTypeArgumentsgenericMethodArguments提供。
metadataToken 在目前模組的範圍內，不是一個有效的令牌。
範例
以下範例展示了如何利用該 ResolveMethod 方法的兩個超載來解析來自一般與非一般上下文中呼叫站點的元資料標記。
程式碼範例定義了兩種通用型別， G1<Tg1>G2<Tg2>且每種類型都有一個通用方法。
G1<Tg1> 也有一個非泛型方法，使用型別參數 Tg1 作為參數。 類型G2<Tg2>中的通用方法GM2<Tgm2>包含數個方法呼叫：
情況一：以型別參數
G2<Tg2>和GM2<Tgm2>作為型別參數來呼叫通用方法GM1<Tgm1>。 換句話說，被呼叫方法的參數型別會依賴於用來從 型G2<Tg2>別定義中構造封閉泛型型的型別。情況二：非泛型方法
M1被呼叫。 此方法的參數使用定義型態的型別參數，G1<Tg1>此時該型別被包圍型態G2<Tg2>的型別參數取代。情況三：通用方法
GM1<Tgm1>被命名為 ，分別 Int32 指定 和 Object 來表示一般型別與通用方法的型別參數。 此方法呼叫不依賴於包圍型別或方法的型別參數。情況四：該類別的
Example非泛型方法M1被呼叫。 此方法呼叫不依賴於包圍型別或方法的型別參數。
此外，範例定義了非泛類 Example 。 這個類別有一個 M 方法可以呼叫一個通用方法。
- 情況 5：被呼叫 generic 方法
GM1<Tgm1>，分別 Int32 指定 和 Object 來表示generic type 和 generic 方法的型別參數。 此方法的上下文沒有包含一般類型或通用方法。
針對每個情況，範例先構造 a MethodInfo 代表被呼叫的方法，然後利用ResolveMethod(Int32, Type[], Type[])方法過載解析標記，並利用 和 Type.GetGenericArgumentsMethodInfo.GetGenericArguments 方法取得 and genericMethodArguments 參數的genericTypeArguments值。 此技術在所有情況下皆有效，因為方法會回傳 Type.EmptyTypes 非泛型上下文。 範例比較了解析 MethodInfo 的 與構造化 MethodInfo的 。
接著範例嘗試利用 ResolveMethod(Int32) 方法過載來解析該標記。 這在情況 3、4 和 5 中有效，因為方法呼叫不依賴於一般上下文。 在第 1 和第 2 種情況下，會拋出例外，因為沒有足夠資訊來解析該標記。
元資料的代幣值以列舉形式硬編碼。 如果你修改這個程式碼範例，標記值很可能會改變。 要確定新的標記值，編譯程式碼並使用 Ildasm.exe 搭配 /TOKENS 選項檢查組合語言。 代幣可在呼叫點找到。 將新值插入列舉，並重新編譯範例。
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
'
備註
在 在作用域中 的型態metadataToken上使用Type.GetGenericArguments方法，取得 的genericTypeArguments通用型別參數陣列。 在 的 方法中使用 MethodInfo.GetGenericArguments ，其中 metadataToken 在作用域中，取得 的 genericMethodArguments通用型別參數陣列。 即使不需要，提出這些論點總是安全的。
Note
關於元資料標記的資訊可在通用語言基礎架構（CLI）文件中找到，特別是「分割區 II：元資料定義與語意」。 欲了解更多資訊，請參閱 ECMA 335 通用語言基礎架構（CLI）。
適用於
ResolveMethod(Int32)
回傳由指定中繼資料標記所識別的方法或建構子。
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 MethodBase參數
- metadataToken
- Int32
一個用來識別模組中方法或建構子的元資料標記。
傳回
一個 MethodBase 代表由指定元資料標記識別的方法或建構子的物件。
例外狀況
metadataToken 在當前模組的作用域中，並非方法或建構子的標記。
-或者-
metadataToken 是 MethodSpec 其簽名包含元素類型 var （泛型的型別參數）或 mvar （泛型方法的型別參數）。
metadataToken 在目前模組的範圍內，不是一個有效的令牌。
範例
以下範例展示了如何利用該 ResolveMethod 方法的兩個超載來解析來自一般與非一般上下文中呼叫站點的元資料標記。
程式碼範例定義了兩種通用型態，G1<Tg1> 和 G2<Tg2>（在 Visual Basic 中G1(Of Tg1) 和 G2(Of Tg2)），每個類型都有通用方法。
G1<Tg1> 也有一個非泛型方法，使用型別參數 Tg1 作為參數。 類型G2<Tg2>中的通用方法GM2<Tgm2>包含數個方法呼叫：
情況一：以型別參數
G2<Tg2>和GM2<Tgm2>作為型別參數來呼叫通用方法GM1<Tgm1>。 換句話說，被呼叫方法的參數型別會依賴於用來從 型G2<Tg2>別定義中構造封閉泛型型的型別。情況二：非泛型方法
M1被呼叫。 此方法的參數使用定義型態的型別參數，G1<Tg1>此時該型別被包圍型態G2<Tg2>的型別參數取代。情況三：通用方法
GM1<Tgm1>被命名為 ，分別 Int32 指定 和 Object 來表示一般型別與通用方法的型別參數。 此方法呼叫不依賴於包圍型別或方法的型別參數。情況四：該類別的
Example非泛型方法M1被呼叫。 此方法呼叫不依賴於包圍型別或方法的型別參數。
此外，範例定義了非泛類 Example 。 此類別有一個 M 方法可呼叫一個泛型方法：
- 情況 5：被呼叫 generic 方法
GM1，分別 Int32 指定 和 Object 來表示generic type 和 generic 方法的型別參數。 此方法的上下文沒有包含一般類型或通用方法。
針對每個情況，範例先構造 a MethodInfo 代表被呼叫的方法，然後利用ResolveMethod(Int32, Type[], Type[])方法過載解析標記，並利用 和 Type.GetGenericArgumentsMethodInfo.GetGenericArguments 方法取得 and genericMethodArguments 參數的genericTypeArguments值。 此技術在所有情況下皆有效，因為方法會回傳 Type.EmptyTypes 非泛型上下文。 範例比較了解析 MethodInfo 的 與構造化 MethodInfo的 。
接著範例嘗試利用 ResolveMethod(Int32) 方法過載來解析該標記。 這在情況 3、4 和 5 中有效，因為方法呼叫不依賴於一般上下文。 在第 1 和第 2 種情況下，會拋出例外，因為沒有足夠資訊來解析該標記。
元資料的代幣值以列舉形式硬編碼。 如果你修改這個程式碼範例，標記值很可能會改變。 要確定新的標記值，編譯程式碼並使用 Ildasm.exe 搭配 /TOKENS 選項檢查組合語言。 代幣可在呼叫點找到。 將新值插入列舉，並重新編譯範例。
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
'
備註
要解析一個包含元素類型ELEMENT_TYPE_VAR或 ELEMENT_TYPE_MVAR的簽章的元資料標記MethodSpec，可以使用ResolveMethod(Int32, Type[], Type[])方法過載，這樣你就能提供必要的上下文。 也就是說，當你解析一個依賴於通用型別及其所嵌入通用方法的方法的元資料標記時，你必須使用允許提供這些類型參數的超載值。
Note
關於元資料標記的資訊可在通用語言基礎架構（CLI）文件中找到，特別是「分割區 II：元資料定義與語意」。 欲了解更多資訊，請參閱 ECMA 335 通用語言基礎架構（CLI）。