Type.GetMethod 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: netstandard.dll

程序集:: mscorlib.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，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, Type[])	搜索其参数与指定泛型参数计数及参数类型匹配的指定公共方法。
GetMethod(String, BindingFlags, Type[])	使用指定的绑定约束搜索其参数与指定参数类型匹配的指定方法。
GetMethod(String, Type[])	搜索其参数与指定参数类型匹配的指定公共方法。
GetMethod(String, BindingFlags)	使用指定绑定约束搜索指定方法。
GetMethod(String)	搜索具有指定名称的公共方法。
GetMethod(String, Type[], ParameterModifier[])	搜索其参数与指定参数类型及修饰符匹配的指定公共方法。

GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

使用指定的绑定约束和指定的调用约定搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。

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

方法的泛型类型参数的数目。

bindingAttr: BindingFlags

枚举值的按位组合，这些值指定如何进行搜索。

或 -

若为 Default，则返回 null。

binder: Binder

一个对象，该对象定义一组属性并启用绑定，而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。

或 -

要使用 Nothing 的空引用（在 Visual Basic 中为 DefaultBinder）。

callConvention: CallingConventions

该对象用于指定要使用的一套规则，这些规则涉及自变量的顺序和布局、传递返回值的方式、用于自变量的寄存器和清理堆栈的方式。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 -

空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

ParameterModifier 对象的数组，表示与 types 数组中的相应元素关联的特性。仅当通过 COM 互操作进行调用时才使用，而且仅处理通过引用传递的参数。默认的联编程序不处理此参数。

MethodInfo

表示与指定泛型参数计数、参数类型、修饰符、绑定约束及调用约定匹配的方法的对象（如果找到的话）；否则为 null。

例外

ArgumentNullException

name 上声明的默认值为 null。

或 -

types 上声明的默认值为 null。

或 -

types 数组中的一个元素是 null。

ArgumentException

genericParameterCount 为负数。

适用于

GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

用指定的绑定约束和指定的调用约定，搜索参数与指定的参数类型及修饰符相匹配的指定方法。

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

包含要获取的方法名称的字符串。

bindingAttr: BindingFlags

枚举值的按位组合，这些值指定如何进行搜索。

或 - 若为 Default，则返回 null。

binder: Binder

一个对象，该对象定义一组属性并启用绑定，而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。

或 - 要使用 Nothing 的空引用（在 Visual Basic 中为 DefaultBinder）。

callConvention: CallingConventions

该对象用于指定要使用的一套规则，这些规则涉及自变量的顺序和布局、传递返回值的方式、用于自变量的寄存器和清理堆栈的方式。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 - 空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

MethodInfo

表示符合指定要求的方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

例外

AmbiguousMatchException

找到多个具有指定名称且与指定绑定约束匹配的方法。

ArgumentNullException

name 上声明的默认值为 null。

或 - types 上声明的默认值为 null。
或 - types 的其中一个元素为 null。

ArgumentException

types 是多维的。

或 - modifiers 是多维的。

示例

下面的示例查找的特定重载，指定绑定约束、调用约定 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);
  }
}


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> MyMethod 的方法 int 。

另请参阅

适用于

GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

使用指定绑定约束，搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定方法。

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

方法的泛型类型参数的数目。

bindingAttr: BindingFlags

枚举值的按位组合，这些值指定如何进行搜索。

或 -

若为 Default，则返回 null。

binder: Binder

一个对象，该对象定义一组属性并启用绑定，而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。

或 -

要使用 Nothing 的空引用（在 Visual Basic 中为 DefaultBinder）。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 -

空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

MethodInfo

表示与指定泛型参数计数、参数类型、修饰符及绑定约束匹配的方法的对象（如果找到的话）；否则为 null。

例外

ArgumentNullException

name 上声明的默认值为 null。

或 -

types 上声明的默认值为 null。

或 -

types 数组中的一个元素是 null。

ArgumentException

genericParameterCount 为负数。

适用于

GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

使用指定绑定约束，搜索其参数与指定自变量类型及修饰符匹配的指定方法。

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

包含要获取的方法名称的字符串。

bindingAttr: BindingFlags

枚举值的按位组合，这些值指定如何进行搜索。

或 - 若为 Default，则返回 null。

binder: Binder

一个对象，该对象定义一组属性并启用绑定，而绑定可能涉及选择重载方法、强制参数类型和通过反射调用成员。

或 - 要使用 Nothing 的空引用（在 Visual Basic 中为 DefaultBinder）。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 - 空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

MethodInfo

表示符合指定要求的方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]) GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

例外

AmbiguousMatchException

找到多个具有指定名称且与指定绑定约束匹配的方法。

ArgumentNullException

name 上声明的默认值为 null。

或 - types 上声明的默认值为 null。
或 - types 的其中一个元素为 null。

ArgumentException

types 是多维的。

或 - modifiers 是多维的。

示例

下面的示例查找的特定重载 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);
  }
}


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

注解

以下 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 的方法。

备注

另请参阅

适用于

GetMethod(String, Int32, Type[], ParameterModifier[])

搜索其参数与指定泛型参数计数、参数类型及修饰符匹配的指定公共方法。

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

方法的泛型类型参数的数目。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 -

空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

MethodInfo

表示与指定泛型参数计数、参数类型及修饰符匹配的公共方法的对象（如果找到的话）；否则为 null。

例外

ArgumentNullException

name 上声明的默认值为 null。

或 -

types 上声明的默认值为 null。

或 -

types 数组中的一个元素是 null。

ArgumentException

genericParameterCount 为负数。

适用于

GetMethod(String, Int32, Type[])

搜索其参数与指定泛型参数计数及参数类型匹配的指定公共方法。

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

方法的泛型类型参数的数目。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 -

空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

MethodInfo

表示其参数与指定泛型参数计数及参数类型匹配的公共方法的对象（如果找到的话）；否则为 null。

例外

ArgumentNullException

name 上声明的默认值为 null。

或 -

types 上声明的默认值为 null。

或 -

types 数组中的一个元素是 null。

ArgumentException

genericParameterCount 为负数。

适用于

GetMethod(String, BindingFlags, Type[])

使用指定的绑定约束搜索其参数与指定参数类型匹配的指定方法。

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 对象数组。

或 - 一个对象的空 (，由字段) 获取 Type EmptyTypes 一个不采用参数的方法。

MethodInfo

表示符合指定要求的方法的对象（如果找到的话）；否则为 null。

适用于

GetMethod(String, Type[])

搜索其参数与指定参数类型匹配的指定公共方法。

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

包含要获取的公共方法的名称的字符串。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 - 空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

MethodInfo

表示其参数与指定参数类型匹配的公共方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String, Type[])

例外

AmbiguousMatchException

找到了多个具有指定名称和指定参数的方法。

ArgumentNullException

name 上声明的默认值为 null。

或 - types 上声明的默认值为 null。
或 - types 的其中一个元素为 null。

ArgumentException

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);
  }
}


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)

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> MyGenericMethod 的方法 int 。请改为 GetMethod("MyGenericMethod") 在数组中将与相应的参数 types 一起使用。

另请参阅

适用于

GetMethod(String, BindingFlags)

使用指定绑定约束搜索指定方法。

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

包含要获取的方法名称的字符串。

bindingAttr: BindingFlags

枚举值的按位组合，这些值指定如何进行搜索。

或 - 若为 Default，则返回 null。

MethodInfo

表示符合指定要求的方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String, BindingFlags) GetMethod(String, BindingFlags)

例外

AmbiguousMatchException

找到多个具有指定名称且与指定绑定约束匹配的方法。

ArgumentNullException

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);
    }
}


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 Example
{
   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)

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 的方法。

备注

另请参阅

适用于

GetMethod(String)

搜索具有指定名称的公共方法。

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

包含要获取的公共方法的名称的字符串。

MethodInfo

表示具有指定名称的公共方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String)

例外

AmbiguousMatchException

找到了多个具有指定名称的方法。

ArgumentNullException

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);
    }
}


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 Example
{
   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.

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.Instance Or BindingFlags.Instance 。
调用 GetMethod 包含参数的方法的重载，该 types 参数定义方法的参数的类型。
调用 GetMethods() 方法以检索包含属于某个类型的所有公共方法的数组。然后，你可以对其进行循环访问以识别名为的重复方法 name 。

如果当前 Type 表示构造的泛型类型，则此方法返回，类型参数 MethodInfo 替换为相应的类型参数。

如果当前表示泛型类型或泛型方法的定义中的类型参数，则此方法将搜索类约束的方法;如果没有类约束，则此方法将搜索 Type Object 的方法。

备注

另请参阅

适用于

GetMethod(String, Type[], ParameterModifier[])

搜索其参数与指定参数类型及修饰符匹配的指定公共方法。

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

包含要获取的公共方法的名称的字符串。

types: Type[]

表示此方法要获取的参数的个数、顺序和类型的 Type 对象数组。

或 - 空的 Type 对象数组（由 EmptyTypes 字段提供），用来获取不采用参数的方法。

modifiers: ParameterModifier[]

MethodInfo

表示符合指定需求的公共方法的对象（如果找到的话）；否则为 null。

实现

GetMethod(String, Type[], ParameterModifier[])

例外

AmbiguousMatchException

找到了多个具有指定名称和指定参数的方法。

ArgumentNullException

name 上声明的默认值为 null。

或 - types 上声明的默认值为 null。
或 - types 的其中一个元素为 null。

ArgumentException

types 是多维的。

或 - modifiers 是多维的。

注解

搜索 name 区分大小写。搜索包括公共静态和公共实例方法。

备注

在查找构造函数和方法时，不能省略参数。只能在调用时省略参数。

如果当前 Type 表示构造的泛型类型，则此方法返回，类型参数 MethodInfo 替换为相应的类型参数。

如果当前表示泛型类型或泛型方法的定义中的类型参数，则此方法将搜索类约束的方法;如果没有类约束，则此方法将搜索 Type Object 的方法。

备注

对于泛型方法，请勿在中包括类型参数 name 。例如，C# 代码搜索文本名称为""的成员，而不是具有类型为的泛型参数的名为 GetMethod("MyMethod<int>") MyMethod<int> MyMethod 的方法 int 。请改为 GetMethod("MyMethod") 在数组中将与相应的参数 types 一起使用。

另请参阅

适用于