Module.ResolveMethod 方法
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。
傳回中繼資料語彙基元所識別的方法。
多載
| ResolveMethod(Int32, Type[], Type[]) |
以指定之泛型型別參數所定義的內容，傳回指定之中繼資料語彙基元所識別的方法或建構函式。 |
| ResolveMethod(Int32) |
傳回指定之中繼資料語彙基元所識別的方法或建構函式。 |
ResolveMethod(Int32, Type[], Type[])
- 來源:
- Module.cs
- 來源:
- Module.cs
- 來源:
- Module.cs
以指定之泛型型別參數所定義的內容，傳回指定之中繼資料語彙基元所識別的方法或建構函式。
public:
virtual System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);public:
System::Reflection::MethodBase ^ ResolveMethod(int metadataToken, cli::array <Type ^> ^ genericTypeArguments, cli::array <Type ^> ^ genericMethodArguments);public virtual System.Reflection.MethodBase? ResolveMethod (int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments);public virtual System.Reflection.MethodBase ResolveMethod (int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);public System.Reflection.MethodBase ResolveMethod (int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);abstract member ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBase
override this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBasemember this.ResolveMethod : int * Type[] * Type[] -> System.Reflection.MethodBasePublic Overridable Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBasePublic Function ResolveMethod (metadataToken As Integer, genericTypeArguments As Type(), genericMethodArguments As Type()) As MethodBase參數
- metadataToken
- Int32
識別模組內方法或建構函式的中繼資料語彙基元。
傳回
MethodBase 物件，表示指定之中繼資料語彙基元所識別的方法。
例外狀況
metadataToken 在目前模組的範圍中不是方法或建構函式的語彙基元。
-或-
metadataToken 是 MethodSpec，其簽章包含項目型別 var (泛型型別的型別參數) 或 mvar (泛型方法的型別參數)，且未提供 genericTypeArguments 和 genericMethodArguments 其一或兩者的泛型型別引數。
metadataToken 在目前模組的範圍中是無效的語彙基元。
範例
下列範例示範如何使用 方法的 ResolveMethod 兩個多載，從泛型和非泛型內容中的呼叫月臺解析中繼資料權杖。
此程式碼範例會定義兩個泛型型別， G1<Tg1> 每個 G2<Tg2> 型別都有泛型方法。 G1<Tg1> 也具有非泛型方法，其會使用型別參數作為其參數 Tg1 。 型 G2<Tg2> 別中的泛型方法 GM2<Tgm2> 包含數個方法呼叫：
案例 1：會呼叫泛型方法
GM1<Tgm1>，並使用 和G2<Tg2>GM2<Tgm2>的類型參數作為型別引數。 換句話說，所呼叫方法的參數類型將取決於用來從 的型別定義G2<Tg2>建構封閉式泛型型別的類型。案例 2：呼叫非泛型方法
M1。 這個方法的 參數會使用定義型別的 type 參數，G1<Tg1>在此案例中會由封入型G2<Tg2>別的 type 參數取代。案例 3：呼叫泛型方法
GM1<Tgm1>，分別指定 Int32 泛 Object 型型別和泛型方法的類型引數和泛型方法。 這個方法呼叫不取決於封入類型或方法的類型參數。案例 4：呼叫 類別的非
Example泛型方法M1。 這個方法呼叫不取決於封入類型或方法的類型參數。
此外，此範例會定義非泛型 Example 類別。 這個類別具有方法 M ，可呼叫泛型方法。
針對每個案例，此範例會先建構 MethodInfo 代表所呼叫方法的 ，然後使用 方法多載解析權杖 ResolveMethod(Int32, Type[], Type[]) ，並使用 Type.GetGenericArguments 和 方法來取得 和 MethodInfo.GetGenericArgumentsgenericMethodArguments 參數的值 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
'
備註
在 Type.GetGenericArguments 範圍中的 型 metadataToken 別上使用 方法，以取得 的泛型型別引數 genericTypeArguments 陣列。 在 MethodInfo.GetGenericArguments 範圍中的 方法上使用 方法 metadataToken ，以取得 的泛型型別引數 genericMethodArguments 陣列。 即使不需要這些引數，也一律安全。
注意
您可以在 Common Language Infrastructure (CLI) 檔中找到中繼資料權杖的相關資訊，特別是「分割 II：元資料定義和語意」。 如需詳細資訊，請參閱 ECMA 335 Common Language Infrastructure (CLI) 。
適用於
ResolveMethod(Int32)
- 來源:
- Module.cs
- 來源:
- Module.cs
- 來源:
- Module.cs
傳回指定之中繼資料語彙基元所識別的方法或建構函式。
public:
System::Reflection::MethodBase ^ ResolveMethod(int metadataToken);public System.Reflection.MethodBase? ResolveMethod (int metadataToken);public System.Reflection.MethodBase ResolveMethod (int metadataToken);member this.ResolveMethod : int -> System.Reflection.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> 包含數個方法呼叫：
案例 1：會呼叫泛型方法
GM1<Tgm1>，並使用 和G2<Tg2>GM2<Tgm2>的類型參數作為型別引數。 換句話說，所呼叫方法的參數類型將取決於用來從 的型別定義G2<Tg2>建構封閉式泛型型別的類型。案例 2：呼叫非泛型方法
M1。 這個方法的 參數會使用定義型別的 type 參數，G1<Tg1>在此案例中會由封入型G2<Tg2>別的 type 參數取代。案例 3：呼叫泛型方法
GM1<Tgm1>，分別指定 Int32 泛 Object 型型別和泛型方法的類型引數和泛型方法。 這個方法呼叫不取決於封入類型或方法的類型參數。案例 4：呼叫 類別的非
Example泛型方法M1。 這個方法呼叫不取決於封入類型或方法的類型參數。
此外，此範例會定義非泛型 Example 類別。 這個類別具有方法 M ，可呼叫泛型方法：
針對每個案例，此範例會先建構 MethodInfo 代表所呼叫方法的 ，然後使用 方法多載解析權杖 ResolveMethod(Int32, Type[], Type[]) ，並使用 Type.GetGenericArguments 和 方法來取得 和 MethodInfo.GetGenericArgumentsgenericMethodArguments 參數的值 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[]) 方法多載，讓您提供必要的內容。 也就是說，當您解析方法的中繼資料權杖時，其相依于泛型型別和/或標記內嵌之泛型方法的泛型型別參數，您必須使用多載，讓您提供這些型別參數。
注意
您可以在 Common Language Infrastructure (CLI) 檔中找到中繼資料權杖的相關資訊，特別是「分割 II：元資料定義和語意」。 如需詳細資訊，請參閱 ECMA 335 Common Language Infrastructure (CLI) 。
適用於
意見反應
即將登場：在 2024 年，我們將逐步淘汰 GitHub 問題作為內容的意見反應機制，並將它取代為新的意見反應系統。 如需詳細資訊，請參閱：https://aka.ms/ContentUserFeedback。
提交並檢視相關的意見反應