Type.GetMethod 方法
定义
重要
一些信息与预发行产品相关,相应产品在发行之前可能会进行重大修改。 对于此处提供的信息,Microsoft 不作任何明示或暗示的担保。
获取当前 Type 的特定方法。
重载
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
使用指定的绑定约束和指定的调用约定搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。 |
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
用指定的绑定约束和指定的调用约定,搜索参数与指定的参数类型及修饰符相匹配的指定方法。 |
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[]) |
使用指定绑定约束,搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。 |
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]) |
使用指定绑定约束,搜索其参数与指定自变量类型及修饰符匹配的指定方法。 |
GetMethod(String, Int32, Type[], ParameterModifier[]) |
搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定公共方法。 |
GetMethod(String, Int32, BindingFlags, Type[]) | |
GetMethod(String, BindingFlags) |
使用指定绑定约束搜索指定方法。 |
GetMethod(String, BindingFlags, Type[]) |
使用指定的绑定约束搜索其参数与指定参数类型匹配的指定方法。 |
GetMethod(String, Int32, Type[]) |
搜索其参数与指定泛型参数计数及参数类型匹配的指定公共方法。 |
GetMethod(String, Type[]) |
搜索其参数与指定参数类型匹配的指定公共方法。 |
GetMethod(String) |
搜索具有指定名称的公共方法。 |
GetMethod(String, Type[], ParameterModifier[]) |
搜索其参数与指定参数类型及修饰符匹配的指定公共方法。 |
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
使用指定的绑定约束和指定的调用约定搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, System::Reflection::CallingConventions callConvention, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * int * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, bindingAttr As BindingFlags, binder As Binder, callConvention As CallingConventions, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
- genericParameterCount
- Int32
方法的泛型类型参数的数目。
- binder
- Binder
一个对象,该对象定义一组属性并启用绑定,而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。
或
要使用 Nothing
的空引用(在 Visual Basic 中为 DefaultBinder)。
- callConvention
- CallingConventions
该对象用于指定要使用的一套规则,这些规则涉及自变量的顺序和布局、传递返回值的方式、用于自变量的寄存器和清理堆栈的方式。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示与指定泛型参数计数、参数类型、修饰符、绑定约束及调用约定匹配的方法的对象(如果找到的话);否则为 null
。
例外
genericParameterCount
为负数。
适用于
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
用指定的绑定约束和指定的调用约定,搜索参数与指定的参数类型及修饰符相匹配的指定方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, System::Reflection::CallingConventions callConvention, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, System::Reflection::CallingConventions callConvention, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
abstract member GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
override this.GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, bindingAttr As BindingFlags, binder As Binder, callConvention As CallingConventions, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的方法名称的字符串。
- binder
- Binder
一个对象,该对象定义一组属性并启用绑定,而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。
或
要使用 Nothing
的空引用(在 Visual Basic 中为 DefaultBinder)。
- callConvention
- CallingConventions
该对象用于指定要使用的一套规则,这些规则涉及自变量的顺序和布局、传递返回值的方式、用于自变量的寄存器和清理堆栈的方式。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示符合指定要求的方法的对象(如果找到的话);否则为 null
。
实现
例外
找到多个具有指定名称且与指定绑定约束匹配的方法。
示例
以下示例查找 的特定重载 MethodA
,指定绑定约束、调用约定和各种参数类型。
注意
Visual C# 2005 示例需要 /unsafe
编译器选项。
using namespace System;
using namespace System::Reflection;
public ref class Program
{
public:
// Methods to get:
void MethodA(int i, int j) { }
void MethodA(array<int>^ iarry) { }
void MethodA(double *ip) { }
// Method that takes a managed reference paramter.
void MethodA(int% r) {}
};
int main()
{
MethodInfo^ mInfo;
// Get MethodA(int i, int j)
mInfo = Program::typeid->GetMethod("MethodA",
BindingFlags::Public | BindingFlags::Instance,
nullptr,
CallingConventions::Any,
gcnew array<Type^> {int::typeid, int::typeid},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(array<int>^ iarry)
mInfo = Program::typeid->GetMethod("MethodA",
BindingFlags::Public | BindingFlags::Instance,
nullptr,
CallingConventions::Any,
gcnew array<Type^> {int::typeid->MakeArrayType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(double *ip)
mInfo = Program::typeid->GetMethod("MethodA",
BindingFlags::Public | BindingFlags::Instance,
nullptr,
CallingConventions::Any,
gcnew array<Type^> {double::typeid->MakePointerType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(int% r)
mInfo = Program::typeid->GetMethod("MethodA",
BindingFlags::Public | BindingFlags::Instance,
nullptr,
CallingConventions::Any,
gcnew array<Type^> {int::typeid->MakeByRefType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
}
using System;
using System.Reflection;
class Program3
{
// Methods to get:
public void MethodA(int i, int j) { }
public void MethodA(int[] i) { }
public unsafe void MethodA(int* i) { }
public void MethodA(ref int r) {}
// Method that takes an out parameter:
public void MethodA(int i, out int o) { o = 100;}
static void Main(string[] args)
{
MethodInfo mInfo;
// Get MethodA(int i, int j)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
CallingConventions.Any,
new Type[] { typeof(int), typeof(int) },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int[] i)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
CallingConventions.Any,
new Type[] { typeof(int[]) },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int* i)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
CallingConventions.Any,
new Type[] { typeof(int).MakePointerType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(ref int r)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
CallingConventions.Any,
new Type[] { typeof(int).MakeByRefType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int i, out int o)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
CallingConventions.Any,
new Type[] { typeof(int), typeof(int).MakeByRefType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
}
}
open System.Reflection
type Program() =
// Methods to get:
member _.MethodA(i: int, j: int) = ()
member _.MethodA(i: int[]) = ()
member _.MethodA(i: int nativeptr) = ()
member _.MethodA(r: int byref) = ()
// Method that takes an outref parameter:
member _.MethodA(i: int, o: int outref) = o <- 100
do
// Get MethodA(int i, int j)
let mInfo =
typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance, null, CallingConventions.Any, [| typeof<int>; typeof<int> |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int[] i)
let mInfo =
typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance, null, CallingConventions.Any, [| typeof<int[]> |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int* i)
let mInfo =
typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance, null, CallingConventions.Any, [| typeof<int>.MakePointerType() |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(ref int r)
let mInfo =
typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance, null, CallingConventions.Any, [| typeof<int>.MakeByRefType() |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int i, out int o)
let mInfo =
typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance, null, CallingConventions.Any, [| typeof<int>; typeof<int>.MakeByRefType() |], null)
printfn $"Found method: {mInfo}"
Imports System.Reflection
Imports System.Runtime.InteropServices
Class Program
' Methods to get:
Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)
End Sub
Public Overloads Sub MethodA(ByVal i() As Integer)
End Sub
Public Overloads Sub MethodA(ByRef r As Integer)
End Sub
' Method that takes an integer and an out parameter. Note that an
' Imports reference is needed to System.Runtime.InteropServices
' for the <OutAttribute>, which can be shortened to <Out>.
Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
o = 100
End Sub
Public Shared Sub Main(ByVal args() As String)
Dim mInfo As MethodInfo
' Get MethodA(ByVal i As Integer, ByVal l As Long)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
CallingConventions.Any, _
New Type() {GetType(System.Int32), _
GetType(System.Int64)}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByVal i() As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
CallingConventions.Any, _
New Type() {GetType(System.Int32())}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByRef r As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
CallingConventions.Any, _
New Type() {GetType(System.Int32).MakeByRefType}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
CallingConventions.Any, _
New Type() {GetType(System.Int32), GetType(System.Int32).MakeByRefType}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
End Sub
End Class
注解
尽管默认联编程序不会处理 ParameterModifier (modifiers
参数) ,但可以使用抽象 System.Reflection.Binder 类编写处理 的 modifiers
自定义绑定器。
ParameterModifier
仅在通过 COM 互操作调用时才使用 ,并且仅处理由引用传递的参数。
下表显示了在对类型进行反射时方法返回 GetXXX
的基类成员。
成员类型 | 静态 | 非静态 |
---|---|---|
构造函数 | 否 | 否 |
字段 | 否 | 可以。 字段始终按名称和签名隐藏。 |
事件 | 不适用 | 常见类型系统规则是继承与实现 属性的方法的继承相同。 反射将属性视为按名称和签名隐藏。 请参阅下面的注释 2。 |
方法 | 否 | 可以。 (虚拟和非虚拟) 的方法可以是按名称隐藏或按名称和签名隐藏。 |
嵌套类型 | 否 | 否 |
properties | 不适用 | 常见的类型系统规则是继承与实现 属性的方法的继承相同。 反射将属性视为按名称和签名隐藏。 请参阅下面的说明 2。 |
按名称隐藏和签名考虑签名的所有部分,包括自定义修饰符、返回类型、参数类型、sentinels 和非托管调用约定。 这是二进制比较。
为了反射,属性和事件是按名称和签名隐藏的。 如果基类中有一个同时具有 get 和 set 访问器的属性,但派生类只有一个 get 访问器,则派生类属性将隐藏基类属性,并且你将无法访问基类上的 setter。
自定义属性不是通用类型系统的一部分。
以下 BindingFlags 筛选器标志可用于定义要在搜索中包括的方法:
必须指定
BindingFlags.Instance
或BindingFlags.Static
才能获得回报。指定
BindingFlags.Public
以在搜索中包含公共方法。指定
BindingFlags.NonPublic
以包括非公共方法 (,即搜索中) 私有、内部和受保护的方法。指定要
BindingFlags.FlattenHierarchy
在层次结构中包括public
和protected
静态成员;private
继承类中的静态成员不包括在层次结构中。
以下 BindingFlags 修饰符标志可用于更改搜索的工作方式:
BindingFlags.IgnoreCase
以忽略 的name
大小写。BindingFlags.DeclaredOnly
如果只搜索 上 Type声明的方法,则搜索只是继承的方法。
有关更多信息,请参见System.Reflection.BindingFlags。
注意
在查找构造函数和方法时,不能省略参数。 只能在调用时省略参数。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法;如果没有类约束,则搜索 的方法 Object 。
注意
对于泛型方法,请勿在 中包含 name
类型参数。 例如,C# 代码GetMember("MyMethod<int>")
搜索文本名称为“”MyMethod<int>
的成员,而不是搜索具有 类型int
的泛型参数的名为 MyMethod
的方法。
另请参阅
- MethodInfo
- String
- BindingFlags
- Binder
- DefaultBinder
- CallingConventions
- ParameterModifier
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()
适用于
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
使用指定绑定约束,搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * int * System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, bindingAttr As BindingFlags, binder As Binder, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
- genericParameterCount
- Int32
方法的泛型类型参数的数目。
- binder
- Binder
一个对象,该对象定义一组属性并启用绑定,而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。
或
要使用 Nothing
的空引用(在 Visual Basic 中为 DefaultBinder)。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示与指定泛型参数计数、参数类型、修饰符及绑定约束匹配的方法的对象(如果找到的话);否则为 null
。
例外
genericParameterCount
为负数。
适用于
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
使用指定绑定约束,搜索其参数与指定自变量类型及修饰符匹配的指定方法。
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, Type[] types, System.Reflection.ParameterModifier[] modifiers);
abstract member GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
override this.GetMethod : string * System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, bindingAttr As BindingFlags, binder As Binder, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的方法名称的字符串。
- binder
- Binder
一个对象,该对象定义一组属性并启用绑定,而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。
或
要使用 Nothing
的空引用(在 Visual Basic 中为 DefaultBinder)。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示符合指定要求的方法的对象(如果找到的话);否则为 null
。
实现
例外
找到多个具有指定名称且与指定绑定约束匹配的方法。
示例
以下示例查找 的特定重载 MethodA
,指定绑定约束和各种参数类型。
注意
Visual C# 2005 示例需要 /unsafe
编译器选项。
using namespace System;
using namespace System::Reflection;
public ref class Program
{
public:
// Methods to get:
void MethodA(int i, int j) { }
void MethodA(array<int>^ iarry) { }
void MethodA(double *ip) { }
// Method that takes a managed reference parameter.
void MethodA(int% r) {}
};
int main()
{
MethodInfo^ mInfo;
// Get MethodA(int i, int j)
mInfo = Program::typeid->GetMethod("MethodA",
static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance),
nullptr,
gcnew array<Type^> {int::typeid, int::typeid},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(array<int>^ iarry)
mInfo = Program::typeid->GetMethod("MethodA",
static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance),
nullptr,
gcnew array<Type^> {int::typeid->MakeArrayType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(double *ip)
mInfo = Program::typeid->GetMethod("MethodA",
static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance),
nullptr,
gcnew array<Type^> {double::typeid->MakePointerType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(int% r)
mInfo = Program::typeid->GetMethod("MethodA",
static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance),
nullptr,
gcnew array<Type^> {int::typeid->MakeByRefType()},
nullptr);
Console::WriteLine("Found method: {0}", mInfo );
}
using System;
using System.Reflection;
class Program5
{
// Methods to get:
public void MethodA(int i, int j) { }
public void MethodA(int[] i) { }
public unsafe void MethodA(int* i) { }
public void MethodA(ref int r) {}
// Method that takes an out parameter.
public void MethodA(int i, out int o) { o = 100; }
static void Main(string[] args)
{
MethodInfo mInfo;
// Get MethodA(int i, int j)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
new Type[] { typeof(int), typeof(int) },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int[] i)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
new Type[] { typeof(int[]) },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int* i)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
new Type[] { typeof(int).MakePointerType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(ref int r)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
new Type[] { typeof(int).MakeByRefType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int i, out int o)
mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance,
null,
new Type[] { typeof(int), typeof(int).MakeByRefType() },
null);
Console.WriteLine("Found method: {0}", mInfo);
}
}
open System
open System.Reflection
type Program() =
// Methods to get:
member _.MethodA(i: int, j: int) = ()
member _.MethodA(i: int[]) = ()
member _.MethodA(i: int nativeptr) = ()
member _.MethodA(r: int byref) = ()
// Method that takes an outref parameter:
member _.MethodA(i: int, o: int outref) = o <- 100
do
// Get MethodA(int i, int j)
let mInfo =
typeof<Program>.GetMethod("MethodA",BindingFlags.Public ||| BindingFlags.Instance, null, [| typeof<int>; typeof<int> |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int[] i)
let mInfo =
typeof<Program>.GetMethod("MethodA",BindingFlags.Public ||| BindingFlags.Instance, null, [| typeof<int[]> |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int* i)
let mInfo =
typeof<Program>.GetMethod("MethodA",BindingFlags.Public ||| BindingFlags.Instance, null, [| typeof<int>.MakePointerType() |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(ref int r)
let mInfo =
typeof<Program>.GetMethod("MethodA",BindingFlags.Public ||| BindingFlags.Instance, null, [| typeof<int>.MakeByRefType() |], null)
printfn $"Found method: {mInfo}"
// Get MethodA(int i, out int o)
let mInfo =
typeof<Program>.GetMethod("MethodA",BindingFlags.Public ||| BindingFlags.Instance, null, [| typeof<int>; typeof<int>.MakeByRefType() |], null)
printfn $"Found method: {mInfo}"
Imports System.Reflection
Imports System.Runtime.InteropServices
Class Program
' Methods to get:
Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)
End Sub
Public Overloads Sub MethodA(ByVal i() As Integer)
End Sub
Public Overloads Sub MethodA(ByRef r As Integer)
End Sub
' Method that takes an out parameter. Note that an Imports
' reference is needed to System.Runtime.InteropServices
' for the <OutAttribute>, which can be shortened to <Out>.
Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
o = 100
End Sub
Public Shared Sub Main(ByVal args() As String)
Dim mInfo As MethodInfo
' Get MethodA(ByVal i As Integer, ByVal l As Long)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
New Type() {GetType(System.Int32), _
GetType(System.Int64)}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByVal i() As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
New Type() {GetType(System.Int32())}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByRef r As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
New Type() {GetType(System.Int32).MakeByRefType}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
mInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance, _
Nothing, _
New Type() {GetType(System.Int32), GetType(System.Int32).MakeByRefType}, _
Nothing)
Console.WriteLine("Found method: {0}", mInfo)
End Sub
End Class
注解
尽管默认绑定器不处理 ParameterModifier (modifiers
参数) ,但可以使用抽象 System.Reflection.Binder 类编写处理 的 modifiers
自定义绑定程序。
ParameterModifier
仅在通过 COM 互操作调用时才使用,并且仅处理由引用传递的参数。
以下 BindingFlags 筛选器标志可用于定义要在搜索中包括的方法:
必须指定
BindingFlags.Instance
或BindingFlags.Static
才能获得回报。指定
BindingFlags.Public
以在搜索中包含公共方法。指定
BindingFlags.NonPublic
以包括非公共方法 (,即搜索中) 私有、内部和受保护的方法。指定要
BindingFlags.FlattenHierarchy
在层次结构中包括public
和protected
静态成员;private
继承类中的静态成员不包括在层次结构中。
以下 BindingFlags 修饰符标志可用于更改搜索的工作方式:
BindingFlags.IgnoreCase
以忽略 的name
大小写。BindingFlags.DeclaredOnly
如果只搜索 上 Type声明的方法,则搜索只是继承的方法。
有关更多信息,请参见System.Reflection.BindingFlags。
注意
在查找构造函数和方法时,不能省略参数。 只能在调用时省略参数。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法;如果没有类约束,则搜索 的方法 Object 。
注意
对于泛型方法,请勿在 中包含 name
类型参数。 例如,C# 代码GetMember("MyMethod<int>")
搜索文本名称为“”MyMethod<int>
的成员,而不是搜索具有 类型int
的泛型参数的名为 MyMethod
的方法。
另请参阅
- MethodInfo
- String
- BindingFlags
- Binder
- DefaultBinder
- ParameterModifier
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()
适用于
GetMethod(String, Int32, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定公共方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, int genericParameterCount, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * int * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
- genericParameterCount
- Int32
方法的泛型类型参数的数目。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示与指定泛型参数计数、参数类型及修饰符匹配的公共方法的对象(如果找到的话);否则为 null
。
例外
genericParameterCount
为负数。
适用于
GetMethod(String, Int32, BindingFlags, Type[])
- Source:
- Type.cs
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo? GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, Type[] types);
member this.GetMethod : string * int * System.Reflection.BindingFlags * Type[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, bindingAttr As BindingFlags, types As Type()) As MethodInfo
参数
- name
- String
- genericParameterCount
- Int32
- bindingAttr
- BindingFlags
- types
- Type[]
返回
适用于
GetMethod(String, BindingFlags)
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
使用指定绑定约束搜索指定方法。
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr);
public System.Reflection.MethodInfo? GetMethod (string name, System.Reflection.BindingFlags bindingAttr);
public System.Reflection.MethodInfo GetMethod (string name, System.Reflection.BindingFlags bindingAttr);
abstract member GetMethod : string * System.Reflection.BindingFlags -> System.Reflection.MethodInfo
override this.GetMethod : string * System.Reflection.BindingFlags -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, bindingAttr As BindingFlags) As MethodInfo
参数
- name
- String
包含要获取的方法名称的字符串。
返回
表示符合指定要求的方法的对象(如果找到的话);否则为 null
。
实现
例外
找到多个具有指定名称且与指定绑定约束匹配的方法。
name
为 null
。
示例
以下示例获取与指定绑定标志匹配的方法。
using namespace System;
using namespace System::Reflection;
public ref class Program
{
public:
// Method to get:
void MethodA() { }
};
int main()
{
// Get MethodA()
MethodInfo^ mInfo = Program::typeid->GetMethod("MethodA",
static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance));
Console::WriteLine("Found method: {0}", mInfo );
}
using System;
using System.Reflection;
class Program2
{
// Method to get:
public void MethodA() { }
static void Main(string[] args)
{
// Get MethodA()
MethodInfo mInfo = typeof(Program).GetMethod("MethodA",
BindingFlags.Public | BindingFlags.Instance);
Console.WriteLine("Found method: {0}", mInfo);
}
}
open System.Reflection
type Program() =
// Method to get:
member _.MethodA() = ()
// Get MethodA()
let mInfo = typeof<Program>.GetMethod("MethodA", BindingFlags.Public ||| BindingFlags.Instance)
printfn $"Found method: {mInfo}"
Imports System.Reflection
Class Program
' Method to get:
Public Sub MethodA()
End Sub
Public Shared Sub Main(ByVal args() As String)
' Get MethodA()
Dim mInfo As MethodInfo = GetType(Program).GetMethod("MethodA", _
BindingFlags.Public Or BindingFlags.Instance)
Console.WriteLine("Found method: {0}", mInfo)
End Sub
End Class
注解
以下 BindingFlags 筛选器标志可用于定义要在搜索中包括的方法:
必须指定 BindingFlags.Instance 或 BindingFlags.Static 才能获得回报。
指定 BindingFlags.Public 以在搜索中包含公共方法。
指定 BindingFlags.NonPublic 以包括非公共方法 (,即搜索中) 私有方法、内部方法和保护方法。
指定要 BindingFlags.FlattenHierarchy 在层次结构中包括
public
和protected
静态成员;private
继承类中的静态成员不包括在层次结构中。
以下 BindingFlags 修饰符标志可用于更改搜索的工作方式:
BindingFlags.IgnoreCase 以忽略 的
name
大小写。BindingFlags.DeclaredOnly 如果只搜索 上 Type声明的方法,则搜索只是继承的方法。
有关更多信息,请参见System.Reflection.BindingFlags。
如果方法已重载,并且多个重载满足 参数指定的 bindingAttr
约束,则该方法将 AmbiguousMatchException 引发异常。 在以下示例中,引发异常的原因是:
类型
TestClass
具有 方法的DisplayValue
两个公共实例重载,DisplayValue(String)
即DisplayValue(String, Object[])
。类型
TestClass
具有 方法的Equals
两个公共实例重载,其中一个继承自 Object:Equals(TestClass)
和Equals(Object)
。
using System;
using System.Reflection;
public class TestClass
{
public void DisplayValue(String s)
{
Console.WriteLine(s);
}
public void DisplayValue(String s, params Object[] values)
{
Console.WriteLine(s, values);
}
public static bool Equals(TestClass t1, TestClass t2)
{
return Object.ReferenceEquals(t1, t2);
}
public bool Equals(TestClass t)
{
return Object.ReferenceEquals(this, t);
}
}
public class Example1
{
public static void Main()
{
Type t = typeof(TestClass);
RetrieveMethod(t, "DisplayValue", BindingFlags.Public | BindingFlags.Instance);
RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance);
RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Static);
}
private static void RetrieveMethod(Type t, String name, BindingFlags flags)
{
try
{
MethodInfo m = t.GetMethod(name, flags);
if (m != null)
{
Console.Write("{0}.{1}(", t.Name, m.Name);
ParameterInfo[] parms = m.GetParameters();
for (int ctr = 0; ctr < parms.Length; ctr++)
{
Console.Write(parms[ctr].ParameterType.Name);
if (ctr < parms.Length - 1)
Console.Write(", ");
}
Console.WriteLine(")");
}
else
{
Console.WriteLine("Method not found");
}
}
catch (AmbiguousMatchException)
{
Console.WriteLine("The following duplicate matches were found:");
MethodInfo[] methods = t.GetMethods(flags);
foreach (var method in methods)
{
if (method.Name != name) continue;
Console.Write(" {0}.{1}(", t.Name, method.Name);
ParameterInfo[] parms = method.GetParameters();
for (int ctr = 0; ctr < parms.Length; ctr++)
{
Console.Write(parms[ctr].ParameterType.Name);
if (ctr < parms.Length - 1)
Console.Write(", ");
}
Console.WriteLine(")");
}
}
Console.WriteLine();
}
}
// The example displays the following output:
// The following duplicate matches were found:
// TestClass.DisplayValue(String)
// TestClass.DisplayValue(String, Object[])
//
// The following duplicate matches were found:
// TestClass.Equals(TestClass)
// TestClass.Equals(Object)
//
// TestClass.Equals(TestClass)
//
// TestClass.Equals(TestClass, TestClass)
open System
open System.Reflection
type TestClass() =
member _.DisplayValue(s) =
printfn $"%s{s}"
member _.DisplayValue(s: string, [<ParamArray>]values: obj[]) =
Console.WriteLine(s, values)
member this.Equals(t: TestClass) =
Object.ReferenceEquals(this, t)
static member Equals(t1: TestClass, t2: TestClass) =
Object.ReferenceEquals(t1, t2)
let retrieveMethod (t: Type) name (flags: BindingFlags) =
try
let m = t.GetMethod(name, flags)
if m <> null then
printf $"{t.Name}.{m.Name}("
let parms = m.GetParameters()
for i = 0 to parms.Length - 1 do
printf $"{parms[i].ParameterType.Name}"
if i < parms.Length - 1 then
printf ", "
printfn ")"
else
printfn "Method not found"
with :? AmbiguousMatchException ->
printfn "The following duplicate matches were found:"
let methods = t.GetMethods flags
for method in methods do
if method.Name = name then
printf $" {t.Name}.{method.Name}("
let parms = method.GetParameters()
for i = 0 to parms.Length - 1 do
printf $"{parms[i].ParameterType.Name}"
if i < parms.Length - 1 then
printf ", "
printfn ")"
printfn ""
let t = typeof<TestClass>
retrieveMethod t "DisplayValue" (BindingFlags.Public ||| BindingFlags.Instance)
retrieveMethod t "Equals" (BindingFlags.Public ||| BindingFlags.Instance)
retrieveMethod t "Equals" (BindingFlags.Public ||| BindingFlags.Instance ||| BindingFlags.DeclaredOnly)
retrieveMethod t "Equals" (BindingFlags.Public ||| BindingFlags.Static)
// The example displays the following output:
// The following duplicate matches were found:
// TestClass.DisplayValue(String)
// TestClass.DisplayValue(String, Object[])
//
// The following duplicate matches were found:
// TestClass.Equals(TestClass)
// TestClass.Equals(Object)
//
// TestClass.Equals(TestClass)
//
// TestClass.Equals(TestClass, TestClass)
Imports System.Reflection
Public Class TestClass
Public Sub DisplayValue(s As String)
Console.WriteLine(s)
End Sub
Public Sub DisplayValue(s As String, ParamArray values() As Object)
Console.WriteLine(s, values)
End Sub
Public Overloads Shared Function Equals(t1 As TestClass, t2 As TestClass) As Boolean
Return Object.ReferenceEquals(t1, t2)
End Function
Public Overloads Function Equals(t As TestClass) As Boolean
Return Object.ReferenceEquals(Me, t)
End Function
End Class
Module Example
Public Sub Main()
Dim t As Type = GetType(TestClass)
RetrieveMethod(t, "DisplayValue", BindingFlags.Public Or BindingFlags.Instance)
RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Instance)
RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.DeclaredOnly)
RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Static)
End Sub
Public Sub RetrieveMethod(t As Type, name As String, flags As BindingFlags)
Try
Dim m As MethodInfo = t.GetMethod(name, flags)
If m IsNot Nothing Then
Console.Write("{0}.{1}(", t.Name, m.Name)
Dim parms() As ParameterInfo = m.GetParameters()
For ctr As Integer = 0 To parms.Length - 1
Console.Write(parms(ctr).ParameterType.Name)
if ctr < parms.Length - 1 Then
Console.Write(", ")
End If
Next
Console.WriteLine(")")
Else
Console.WriteLine("Method not found")
End If
Catch e As AmbiguousMatchException
Console.WriteLine("The following duplicate matches were found:")
Dim methods() As MethodInfo = t.GetMethods(flags)
For Each method In methods
If method.Name <> name Then Continue For
Console.Write(" {0}.{1}(", t.Name, method.Name)
Dim parms() As ParameterInfo = method.GetParameters()
For ctr As Integer = 0 To parms.Length - 1
Console.Write(parms(ctr).ParameterType.Name)
if ctr < parms.Length - 1 Then
Console.Write(", ")
End If
Next
Console.WriteLine(")")
Next
End Try
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' The following duplicate matches were found:
' TestClass.DisplayValue(String)
' TestClass.DisplayValue(String, Object[])
'
' The following duplicate matches were found:
' TestClass.Equals(TestClass)
' TestClass.Equals(Object)
'
' TestClass.Equals(TestClass)
'
' TestClass.Equals(TestClass, TestClass)
可以执行以下操作之一来检索特定方法:
更改绑定约束。 在前面的示例中,尝试检索由 类型声明但未继承的公共实例
Equals
方法会成功检索Equals(TestClass)
。调用 方法的 GetMethod 重载,该方法包含
types
定义方法参数类型的参数。GetMethods(BindingFlags)调用 方法以检索包含属于具有指定绑定属性的类型的所有方法的数组。 然后,可以循环访问它以标识名为
name
的重复方法。 此方法在上一示例的异常处理程序 AmbiguousMatchException 中进行了说明。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法;如果没有类约束,则搜索 的方法 Object 。
注意
对于泛型方法,请勿在 中包含 name
类型参数。 例如,C# 代码GetMember("MyMethod<int>")
搜索文本名称为“”MyMethod<int>
的成员,而不是搜索具有 类型int
的泛型参数的名为 MyMethod
的方法。
另请参阅
- MethodInfo
- String
- BindingFlags
- DefaultBinder
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()
适用于
GetMethod(String, BindingFlags, Type[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
使用指定的绑定约束搜索其参数与指定参数类型匹配的指定方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo? GetMethod (string name, System.Reflection.BindingFlags bindingAttr, Type[] types);
member this.GetMethod : string * System.Reflection.BindingFlags * Type[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, bindingAttr As BindingFlags, types As Type()) As MethodInfo
参数
- name
- String
包含要获取的方法名称的字符串。
- bindingAttr
- BindingFlags
枚举值的按位组合,这些值指定如何进行搜索。
-或 - 默认返回 null
。
- types
- Type[]
表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。 - 或 - (字段提供的EmptyTypes空对象数组 Type) 获取不采用任何参数的方法。
返回
表示符合指定要求的方法的对象(如果找到的话);否则为 null
。
适用于
GetMethod(String, Int32, Type[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
搜索其参数与指定泛型参数计数及参数类型匹配的指定公共方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo? GetMethod (string name, int genericParameterCount, Type[] types);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, Type[] types);
member this.GetMethod : string * int * Type[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, types As Type()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
- genericParameterCount
- Int32
方法的泛型类型参数的数目。
返回
表示其参数与指定泛型参数计数及参数类型匹配的公共方法的对象(如果找到的话);否则为 null
。
例外
genericParameterCount
为负数。
适用于
GetMethod(String, Type[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
搜索其参数与指定参数类型匹配的指定公共方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, cli::array <Type ^> ^ types);
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo? GetMethod (string name, Type[] types);
public System.Reflection.MethodInfo GetMethod (string name, Type[] types);
member this.GetMethod : string * Type[] -> System.Reflection.MethodInfo
abstract member GetMethod : string * Type[] -> System.Reflection.MethodInfo
override this.GetMethod : string * Type[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, types As Type()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
返回
表示其参数与指定参数类型匹配的公共方法的对象(如果找到的话);否则为 null
。
实现
例外
找到了多个具有指定名称和指定参数的方法。
types
是多维的。
示例
以下示例查找 的特定 MethodA
重载,并指定各种参数类型。
注意
Visual C# 2005 示例需要 /unsafe
编译器选项。
using namespace System;
using namespace System::Reflection;
public ref class Program
{
public:
// Methods to get:
void MethodA(int i, int j) { }
void MethodA(array<int>^ iarry) { }
void MethodA(double *ip) { }
// Method that takes a managed reference parameter.
void MethodA(int% r) {}
};
int main()
{
MethodInfo^ mInfo;
// Get MethodA(int i, int j)
mInfo = Program::typeid->GetMethod("MethodA", gcnew array<Type^> {int::typeid,int::typeid});
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(array<int>^ iarry)
mInfo = Program::typeid->GetMethod("MethodA", gcnew array<Type^> {int::typeid->MakeArrayType()});
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(double *ip)
mInfo = Program::typeid->GetMethod("MethodA", gcnew array<Type^> {double::typeid->MakePointerType()});
Console::WriteLine("Found method: {0}", mInfo );
// Get MethodA(int% r)
mInfo = Program::typeid->GetMethod("MethodA", gcnew array<Type^> {int::typeid->MakeByRefType()});
// Display the method information.
Console::WriteLine("Found method: {0}", mInfo );
}
using System;
using System.Reflection;
class Program4
{
// Methods to get:
public void MethodA(int i, int j) { }
public void MethodA(int[] i) { }
public unsafe void MethodA(int* i) { }
public void MethodA(ref int r) {}
// Method that takes an out parameter:
public void MethodA(int i, out int o) { o = 100;}
static void Main(string[] args)
{
MethodInfo mInfo;
// Get MethodA(int i, int i)
mInfo = typeof(Program).GetMethod("MethodA",
new Type[] { typeof(int), typeof(int) });
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int[] i)
mInfo = typeof(Program).GetMethod("MethodA",
new Type[] { typeof(int[]) });
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int* i)
mInfo = typeof(Program).GetMethod("MethodA",
new Type[] { typeof(int).MakePointerType() });
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(ref int r)
mInfo = typeof(Program).GetMethod("MethodA",
new Type[] { typeof(int).MakeByRefType() });
Console.WriteLine("Found method: {0}", mInfo);
// Get MethodA(int i, out int o)
mInfo = typeof(Program).GetMethod("MethodA",
new Type[] { typeof(int), typeof(int).MakeByRefType() });
Console.WriteLine("Found method: {0}", mInfo);
}
}
type Program() =
// Methods to get:
member _.MethodA(i: int, j: int) = ()
member _.MethodA(i: int[]) = ()
member _.MethodA(i: int nativeptr) = ()
member _.MethodA(r: int byref) = ()
// Method that takes an outref parameter:
member _.MethodA(i: int, o: int outref) = o <- 100
do
// member MethodA: i: int * j: int -> unit
let mInfo = typeof<Program>.GetMethod("MethodA", [| typeof<int>; typeof<int> |])
printfn $"Found method: {mInfo}"
// member MethodA: i: int[] -> unit
let mInfo = typeof<Program>.GetMethod("MethodA", [| typeof<int[]> |])
printfn $"Found method: {mInfo}"
// member MethodA: i: nativeptr<int> -> unit
let mInfo = typeof<Program>.GetMethod("MethodA", [| typeof<int>.MakePointerType() |])
printfn $"Found method: {mInfo}"
// member MethodA: r: byref<int> -> unit
let mInfo = typeof<Program>.GetMethod("MethodA", [| typeof<int>.MakeByRefType() |])
printfn $"Found method: {mInfo}"
// member MethodA: i: int * o: outref<int> -> unit
let mInfo = typeof<Program>.GetMethod("MethodA", [| typeof<int>; typeof<int>.MakeByRefType() |])
printfn $"Found method: {mInfo}"
Imports System.Reflection
Imports System.Runtime.InteropServices
Class Program
' Methods to get:
Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)
End Sub
Public Overloads Sub MethodA(ByVal i() As Integer)
End Sub
Public Overloads Sub MethodA(ByRef r As Integer)
End Sub
' Method that takes an out parameter. Note that an Imports
' reference is needed to System.Runtime.InteropServices
' for the <OutAttribute>, which can be shortened to <Out>.
Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
o = 100
End Sub
Public Shared Sub Main(ByVal args() As String)
Dim mInfo As MethodInfo
' Get MethodA(i As Integer i, l As Long)
mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer), GetType(Long)})
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(i As Integer())
mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer())})
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(ByRef r As Integer)
mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer).MakeByRefType})
Console.WriteLine("Found method: {0}", mInfo)
' Get MethodA(i As Integer, ByRef r As Integer)
mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer), _
GetType(Integer).MakeByRefType})
Console.WriteLine("Found method: {0}", mInfo)
End Sub
End Class
以下示例检索 MethodInfo 表示 Add
非泛型类型方法的对象 (类) ArrayList 、) 类 (List<T> 打开的泛型类型以及 (该 List(Of String)
类型的封闭泛型类型。
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
public class Example
{
public static void Main()
{
// Get a Type object that represents a non-generic type.
GetAddMethod(typeof(ArrayList));
var list = new List<String>();
// Get a Type object that represents a constructed generic type.
Type closed = list.GetType();
GetAddMethod(closed);
// Get a Type object that represents an open generic type.
Type open = typeof(List<>);
GetAddMethod(open);
}
private static void GetAddMethod(Type typ)
{
MethodInfo method;
// Determine if this is a generic type.
if (typ.IsGenericType) {
// Is it an open generic type?
if (typ.ContainsGenericParameters)
method = typ.GetMethod("Add", typ.GetGenericArguments());
// Get closed generic type arguments.
else
method = typ.GetMethod("Add", typ.GenericTypeArguments);
}
// This is not a generic type.
else {
method = typ.GetMethod("Add", new Type[] { typeof(Object) } );
}
// Test if an Add method was found.
if (method == null) {
Console.WriteLine("No Add method found.");
return;
}
Type t = method.ReflectedType;
Console.Write("{0}.{1}.{2}(", t.Namespace, t.Name, method.Name);
ParameterInfo[] parms = method.GetParameters();
for (int ctr = 0; ctr < parms.Length; ctr++)
Console.Write("{0}{1}", parms[ctr].ParameterType.Name,
ctr < parms.Length - 1 ? ", " : "");
Console.WriteLine(")");
}
}
// The example displays the following output:
// System.Collections.ArrayList.Add(Object)
// System.Collections.Generic.List`1.Add(String)
// System.Collections.Generic.List`1.Add(T)
open System
open System.Collections
let getAddMethod (typ: Type) =
let method =
// Determine if this is a generic type.
if typ.IsGenericType then
// Is it an open generic type?
if typ.ContainsGenericParameters then
typ.GetMethod("Add", typ.GetGenericArguments())
// Get closed generic type arguments.
else
typ.GetMethod("Add", typ.GenericTypeArguments)
// This is not a generic type.
else
typ.GetMethod("Add", [| typeof<obj> |])
// Test if an Add method was found.
if method = null then
printfn "No Add method found."
else
let t = method.ReflectedType
printf $"{t.Namespace}.{t.Name}.{method.Name}("
let parms = method.GetParameters()
for i = 0 to parms.Length - 1 do
printf $"""{parms[i].ParameterType.Name}{if i < parms.Length - 1 then ", " else ""}"""
printfn ")"
// Get a Type object that represents a non-generic type.
getAddMethod typeof<ArrayList>
let list = ResizeArray<String>()
// Get a Type object that represents a constructed generic type.
let closed = list.GetType()
getAddMethod closed
// Get a Type object that represents an open generic type.
let opn = typeof<ResizeArray<_>>.GetGenericTypeDefinition()
getAddMethod opn
// The example displays the following output:
// System.Collections.ArrayList.Add(Object)
// System.Collections.Generic.List`1.Add(String)
// System.Collections.Generic.List`1.Add(T)
Imports System.Collections
Imports System.Collections.Generic
Imports System.Reflection
Module Example
Public Sub Main()
' Get a Type object that represents a non-generic type.
GetAddMethod(GetType(ArrayList))
Dim list As New List(Of String)()
' Get a Type object that represents a constructed generic type.
Dim closed As Type = list.GetType()
GetAddMethod(closed)
' Get a Type object that represents an open generic type.
Dim open As Type = GetType(List(Of))
GetAddMethod(open)
End Sub
Private Sub GetAddMethod(typ As Type)
Dim method As MethodInfo
' Determine if this is a generic type.
If typ.IsGenericType Then
' Is it an open generic type?
If typ.ContainsGenericParameters Then
method = typ.GetMethod("Add", typ.GetGenericArguments())
' Get closed generic type arguments.
Else
method = typ.GetMethod("Add", typ.GenericTypeArguments)
End If
' This is not a generic type.
Else
method = typ.GetMethod("Add", { GetType(Object) } )
End If
' Test if an Add method was found.
If method Is Nothing Then
Console.WriteLine("No Add method found.")
Exit Sub
End If
Dim t As Type = method.ReflectedType
Console.Write("{0}.{1}.{2}(", t.Namespace, t.Name, method.Name)
Dim params() As ParameterInfo = method.GetParameters()
For ctr As Integer = 0 To params.Length - 1
Console.Write("{0}{1}", params(ctr).ParameterType.Name,
If(ctr < params.Length - 1, ", ", ""))
Next
Console.WriteLine(")")
End Sub
End Module
' The example displays the following output:
' System.Collections.ArrayList.Add(Object)
' System.Collections.Generic.List`1.Add(String)
' System.Collections.Generic.List`1.Add(T)
该示例定义检索 GetAddMethod
相应 MethodInfo 对象的方法。 若要为开放泛型类型提供 types
参数,它调用 Type.GetGenericArguments 方法。 若要为封闭泛型类型提供 types
参数,它将检索 属性的值 Type.GenericTypeArguments 。
注解
搜索区分 name
大小写。 搜索包括公共静态和公共实例方法。
注意
在查找构造函数和方法时,不能省略参数。 只能在调用时省略参数。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法;如果没有类约束,则搜索 的方法 Object 。
注意
参数 name
不能包含类型参数。 例如,C# 代码GetMethod("MyGenericMethod<int>")
搜索文本名称为“”MyGenericMethod<int>
的方法,而不是搜索具有类型 int
为 的泛型参数的名为 MyGenericMethod
的方法。
GetMethod("MyGenericMethod")
请改用 数组中的types
相应参数。
另请参阅
- MethodInfo
- DefaultBinder
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()
适用于
GetMethod(String)
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
搜索具有指定名称的公共方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name);
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name);
public System.Reflection.MethodInfo? GetMethod (string name);
public System.Reflection.MethodInfo GetMethod (string name);
member this.GetMethod : string -> System.Reflection.MethodInfo
abstract member GetMethod : string -> System.Reflection.MethodInfo
override this.GetMethod : string -> System.Reflection.MethodInfo
Public Function GetMethod (name As String) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
返回
表示具有指定名称的公共方法的对象(如果找到的话);否则为 null
。
实现
例外
找到了多个具有指定名称的方法。
name
为 null
。
示例
以下示例获取名为 的方法 MethodA
。
using namespace System;
using namespace System::Reflection;
public ref class Program
{
public:
// Method to get:
void MethodA() { }
};
int main()
{
// Get MethodA()
MethodInfo^ mInfo = Program::typeid->GetMethod("MethodA");
Console::WriteLine("Found method: {0}", mInfo );
}
using System;
using System.Reflection;
class Program
{
// Method to get:
public void MethodA() { }
static void Main(string[] args)
{
// Get MethodA()
MethodInfo mInfo = typeof(Program).GetMethod("MethodA");
Console.WriteLine("Found method: {0}", mInfo);
}
}
type Program() =
// Method to get:
member _.MethodA() = ()
// Get MethodA()
let mInfo = typeof<Program>.GetMethod "MethodA"
printfn $"Found method: {mInfo}"
Imports System.Reflection
Class Program
' Method to get:
Public Sub MethodA()
End Sub
Public Shared Sub Main(ByVal args() As String)
' Get MethodA()
Dim mInfo As MethodInfo = GetType(Program).GetMethod("MethodA")
Console.WriteLine("Found method: {0}", mInfo)
End Sub
End Class
注解
搜索 name
区分大小写。 搜索包括公共静态和公共实例方法。
如果方法重载并且有多个公共方法,该方法 GetMethod(String) 将 AmbiguousMatchException 引发异常。 在下面的示例中,由于 方法有多个公共重载 Int32.ToString ,因此会引发异常。 另一方面,由于 Person.ToString
方法重写 Object.ToString ,因此不会重载,因此该方法 GetMethod(String) 能够检索 MethodInfo 对象。
using System;
using System.Reflection;
public class Person
{
public String FirstName;
public String LastName;
public override String ToString()
{
return (FirstName + " " + LastName).Trim();
}
}
public class Example2
{
public static void Main()
{
Type t = typeof(Person);
RetrieveMethod(t, "ToString");
t = typeof(Int32);
RetrieveMethod(t, "ToString");
}
private static void RetrieveMethod(Type t, String name)
{
try
{
MethodInfo m = t.GetMethod(name);
if (m != null)
Console.WriteLine("{0}.{1}: {2} method", m.ReflectedType.Name,
m.Name, m.IsStatic ? "Static" : "Instance");
else
Console.WriteLine("{0}.ToString method not found", t.Name);
}
catch (AmbiguousMatchException)
{
Console.WriteLine("{0}.{1} has multiple public overloads.",
t.Name, name);
}
}
}
// The example displays the following output:
// Person.ToString: Instance method
// Int32.ToString has multiple public overloads.
open System
open System.Reflection
type Person() =
member val FirstName = "" with get, set
member val LastName = "" with get, set
override this.ToString() =
(this.FirstName + " " + this.LastName).Trim()
let retrieveMethod (t: Type) name =
try
let m = t.GetMethod name
if m <> null then
printfn $"""{m.ReflectedType.Name}.{m.Name}: {if m.IsStatic then "Static" else "Instance"} method"""
else
printfn $"{t.Name}.ToString method not found"
with :? AmbiguousMatchException ->
printfn $"{t.Name}.{name} has multiple public overloads."
let t = typeof<Person>
retrieveMethod t "ToString"
let t2 = typeof<int>
retrieveMethod t2 "ToString"
// The example displays the following output:
// Person.ToString: Instance method
// Int32.ToString has multiple public overloads.
Imports System.Reflection
Public Class Person
Public FirstName As String
Public LastName As String
Public Overrides Function ToString() As String
Return (FirstName + " " + LastName).Trim()
End Function
End Class
Module Example
Public Sub Main()
Dim t As Type = GetType(Person)
RetrieveMethod(t, "ToString")
t = GetType(Int32)
RetrieveMethod(t, "ToString")
End Sub
Private Sub RetrieveMethod(t As Type, name As String)
Try
Dim m As MethodInfo = t.GetMethod(name)
If m IsNot Nothing Then
Console.WriteLine("{0}.{1}: {2} method", m.ReflectedType.Name,
m.Name, If(m.IsStatic, "Static", "Instance"))
Else
Console.WriteLine("{0}.ToString method not found", t.Name)
End If
Catch e As AmbiguousMatchException
Console.WriteLine("{0}.{1} has multiple public overloads.",
t.Name, name)
End Try
End Sub
End Module
' The example displays the following output:
' Person.ToString: Instance method
' Int32.ToString has multiple public overloads.
可以执行以下操作之一来检索特定方法:
GetMethod(String, BindingFlags)调用 方法并指定唯一
bindingAttr
标识方法的参数。 例如,如果由于类型具有静态和实例重载而引发异常,则可以指定bindingAttr
参数 BindingFlags.InstanceOr
BindingFlags.Instance。调用 方法的 GetMethod 重载,其中包含
types
定义方法参数类型的 参数。GetMethods()调用 方法以检索包含属于某个类型的所有公共方法的数组。 然后,可以循环访问它以标识名为
name
的重复方法。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法,如果没有类约束,则搜索 的方法 Object 。
注意
对于泛型方法,请勿在 中包含 name
类型参数。 例如,C# 代码GetMember("MyMethod<int>")
搜索文本名称为“”MyMethod<int>
的成员,而不是搜索具有类型 int
为 的泛型参数的名为 MyMethod
的方法。
另请参阅
- MethodInfo
- String
- DefaultBinder
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()
适用于
GetMethod(String, Type[], ParameterModifier[])
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
搜索其参数与指定参数类型及修饰符匹配的指定公共方法。
public:
System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public:
virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo? GetMethod (string name, Type[] types, System.Reflection.ParameterModifier[]? modifiers);
public System.Reflection.MethodInfo GetMethod (string name, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
abstract member GetMethod : string * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
override this.GetMethod : string * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, types As Type(), modifiers As ParameterModifier()) As MethodInfo
参数
- name
- String
包含要获取的公共方法的名称的字符串。
- modifiers
- ParameterModifier[]
ParameterModifier 对象的数组,表示与 types
数组中的相应元素关联的特性。 仅当通过 COM 互操作进行调用时才使用,而且仅处理通过引用传递的参数。 默认的联编程序不处理此参数。
返回
表示符合指定需求的公共方法的对象(如果找到的话);否则为 null
。
实现
例外
找到了多个具有指定名称和指定参数的方法。
注解
尽管默认联编程序不会处理 ParameterModifier (modifiers
参数) ,但可以使用抽象 System.Reflection.Binder 类编写处理 的 modifiers
自定义绑定器。
ParameterModifier
仅在通过 COM 互操作调用时才使用 ,并且仅处理由引用传递的参数。
搜索 name
区分大小写。 搜索包括公共静态和公共实例方法。
注意
在查找构造函数和方法时,不能省略参数。 只能在调用时省略参数。
如果当前 Type 表示构造的泛型类型,则此方法返回 MethodInfo ,并将类型参数替换为相应的类型参数。
如果当前 Type 表示泛型类型或泛型方法的定义中的类型参数,则此方法将搜索类约束的方法,如果没有类约束,则搜索 的方法 Object 。
注意
对于泛型方法,请勿在 中包含 name
类型参数。 例如,C# 代码GetMethod("MyMethod<int>")
搜索文本名称为“”MyMethod<int>
的成员,而不是搜索具有类型 int
为 的泛型参数的名为 MyMethod
的方法。 请改为将 与 数组中的types
相应参数一GetMethod("MyMethod")
起使用。
另请参阅
- MethodInfo
- String
- DefaultBinder
- ParameterModifier
- GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
- GetMethods()