Type.GetMethod Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Získá konkrétní metodu aktuálního Typeobjektu .

Přetížení

GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům pomocí zadaných omezení vazby.
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům pomocí zadaných omezení vazby.
GetMethod(String, Int32, Type[], ParameterModifier[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům.
GetMethod(String, Int32, BindingFlags, Type[])
GetMethod(String, BindingFlags)	Vyhledá zadanou metodu pomocí zadaných omezení vazby.
GetMethod(String, BindingFlags, Type[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů pomocí zadaných omezení vazby.
GetMethod(String, Int32, Type[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů.
GetMethod(String, Type[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů.
GetMethod(String)	Vyhledá veřejnou metodu se zadaným názvem.
GetMethod(String, Type[], ParameterModifier[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

genericParameterCount: Int32

Počet parametrů obecného typu metody.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují, jak se provádí hledání.

-nebo-

Default a vrátí nullse .

binder: Binder

Objekt, který definuje sadu vlastností a umožňuje vázání, jež může zahrnovat výběr přetěžované metody, vynucení typů argumentů a vyvolání členu prostřednictvím reflexe.

-nebo-

Odkaz null (Nothing v jazyce Visual Basic) pro použití DefaultBinder.

callConvention: CallingConventions

Objekt, který určuje sadu pravidel, která se mají použít, pokud jde o pořadí a rozložení argumentů, způsob předávání návratové hodnoty, jaké registry se používají pro argumenty a jak je zásobník vyčištěn.

types: Type[]

Pole Type objektů představující číslo, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Pole ParameterModifier objektů představující atributy přidružené k odpovídajícímu prvku v types poli. Používá se pouze při volání prostřednictvím zprostředkovatele komunikace COM a jsou zpracovány pouze parametry, které jsou předány odkazem. Výchozí vázací objekt tento parametr nezpracovává.

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadanému počtu obecných parametrů, typům argumentů, modifikátorům, omezením vazby a konvenci volání, pokud jsou nalezeny; v opačném případě . null

Výjimky

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types poli je null.

ArgumentException

genericParameterCount je negativní.

Platí pro

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.

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

Parametry

name: String

Řetězec obsahující název metody, která má být získána.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují, jak se provádí hledání.

-nebo-

Default a vrátí nullse .

binder: Binder

Objekt, který definuje sadu vlastností a umožňuje vázání, jež může zahrnovat výběr přetěžované metody, vynucení typů argumentů a vyvolání členu prostřednictvím reflexe.

-nebo-

Odkaz null (Nothing v jazyce Visual Basic) pro použití DefaultBinder.

callConvention: CallingConventions

types: Type[]

Pole Type objektů představující číslo, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadaným požadavkům, pokud je nalezen; v opačném případě . null

Implementuje

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

Výjimky

AmbiguousMatchException

Byla nalezena více než jedna metoda se zadaným názvem, která odpovídá zadaným omezením vazby.

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types souboru je null.

ArgumentException

Pole types je multidimenzionální.

-nebo-

Pole modifiers je multidimenzionální.

Příklady

Následující příklad najde konkrétní přetížení , MethodAurčující omezení vazby, konvence volání a různé typy argumentů.

Poznámka

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /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

Poznámky

I když výchozí pořadač nezpracovává ParameterModifier ( modifiers parametr), můžete použít abstraktní System.Reflection.Binder třídu k zápisu vlastního pořadače, který zpracovává modifiers. ParameterModifier se používá pouze při volání prostřednictvím zprostředkovatele komunikace COM a jsou zpracovány pouze parametry, které jsou předány odkazem.

Následující tabulka ukazuje, jaké členy základní třídy jsou vráceny metodami GetXXX při odrazu na typu.

Typ členu	Static	Nestatický
Konstruktor	No	No
Pole	No	Yes. Pole je vždy skrýváno podle názvu a podpisu.
Událost	Neuvedeno	Pro systém typů platí obecné pravidlo, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe pracuje s třídami jako se skrývanými podle názvu a podpisu. Viz poznámka 2 níže.
Metoda	No	Yes. Metody (virtuální i nevirtuální) mohou být skrývány podle názvu nebo podle názvu a podpisu.
Vnořený typ	No	No
Vlastnost	Neuvedeno	Pro systém typů platí obecné pravidlo, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe pracuje s třídami jako se skrývanými podle názvu a podpisu. Viz poznámka 2 níže.

Skrývání podle názvu a podpisu bere v úvahu všechny části podpisu včetně vlastních modifikátorů, návratových typů, typů parametrů, sentinelů a nespravovaných konvencí volání. Jedná se o binární porovnání.
Pro účely reflexe jsou vlastnosti a události skrývány podle názvu a podpisu. Má-li vlastnost v základní třídě přístupové metody get i set, ale odvozená třída má pouze přístupovou metodu get, vlastnost odvozené třídy skryje vlastnost základní třídy a nebudete mít k dispozici přístup k metodě set základní třídy.
Vlastní atributy nejsou součástí systému společných typů.

BindingFlags Následující příznaky filtru lze použít k definování metod, které se mají zahrnout do hledání:

Pokud chcete získat vrácení, musíte zadat buď BindingFlags.Instance nebo BindingFlags.Static .
Zadejte BindingFlags.Public , aby se do hledání zahrnuly veřejné metody.
Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuly neveřejné metody (tj. soukromé, interní a chráněné metody).
Zadejte BindingFlags.FlattenHierarchy zahrnutí public a protected statické členy v hierarchii; private statické členy ve zděděných třídách nejsou zahrnuty.

Pomocí následujících BindingFlags modifikačních příznaků můžete změnit fungování vyhledávání:

BindingFlags.IgnoreCase pokud chcete ignorovat případ name.
BindingFlags.DeclaredOnly prohledávat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Poznámka

Při hledání konstruktorů a metod nelze parametry vynechávat. Můžete je vynechat pouze při vyvolání.

Pokud proud Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda hodnotu s parametry typu nahrazenými příslušnými argumenty typu.

Pokud current Type představuje parametr typu v definici obecného typu nebo obecné metody, tato metoda prohledá metody omezení třídy nebo metody Object , pokud neexistuje žádné omezení třídy.

Poznámka

U obecných metod nezahrnujte argumenty typu v namesouboru . Například kód GetMember("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli metodu s názvem MyMethod , která má jeden obecný argument typu int.

Viz také

Platí pro

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům pomocí zadaných omezení vazby.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

genericParameterCount: Int32

Počet parametrů obecného typu metody.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují, jak se provádí hledání.

-nebo-

Default a vrátí nullse .

binder: Binder

Objekt, který definuje sadu vlastností a umožňuje vázání, jež může zahrnovat výběr přetěžované metody, vynucení typů argumentů a vyvolání členu prostřednictvím reflexe.

-nebo-

Odkaz null (Nothing v jazyce Visual Basic) pro použití DefaultBinder.

types: Type[]

Pole Type objektů představující číslo, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadanému počtu obecných parametrů, typům argumentů, modifikátorům a omezením vazby, pokud jsou nalezeny; v opačném případě . null

Výjimky

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types poli je null.

ArgumentException

genericParameterCount je negativní.

Platí pro

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům pomocí zadaných omezení vazby.

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

Parametry

name: String

Řetězec obsahující název metody, která má být získána.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují, jak se provádí hledání.

-nebo-

Default a vrátí nullse .

binder: Binder

Objekt, který definuje sadu vlastností a umožňuje vázání, jež může zahrnovat výběr přetěžované metody, vynucení typů argumentů a vyvolání členu prostřednictvím reflexe.

-nebo-

Odkaz null (Nothing v jazyce Visual Basic) pro použití DefaultBinder.

types: Type[]

Pole Type objektů představující číslo, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadaným požadavkům, pokud je nalezen; v opačném případě . null

Implementuje

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

Výjimky

AmbiguousMatchException

Byla nalezena více než jedna metoda se zadaným názvem, která odpovídá zadaným omezením vazby.

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types souboru je null.

ArgumentException

Pole types je multidimenzionální.

-nebo-

Pole modifiers je multidimenzionální.

Příklady

Následující příklad najde konkrétní přetížení , MethodAurčující vazby omezení a různé typy argumentů.

Poznámka

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /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

Poznámky

BindingFlags Následující příznaky filtru lze použít k definování metod, které se mají zahrnout do hledání:

Pokud chcete získat vrácení, musíte zadat buď BindingFlags.Instance nebo BindingFlags.Static .
Zadejte BindingFlags.Public , aby se do hledání zahrnuly veřejné metody.
Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuly neveřejné metody (tj. soukromé, interní a chráněné metody).
Zadejte BindingFlags.FlattenHierarchy zahrnutí public a protected statické členy v hierarchii; private statické členy ve zděděných třídách nejsou zahrnuty.

Pomocí následujících BindingFlags modifikačních příznaků můžete změnit fungování vyhledávání:

BindingFlags.IgnoreCase pokud chcete ignorovat případ name.
BindingFlags.DeclaredOnly prohledávat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Poznámka

Při hledání konstruktorů a metod nelze parametry vynechávat. Můžete je vynechat pouze při vyvolání.

Pokud proud Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda hodnotu s parametry typu nahrazenými příslušnými argumenty typu.

Poznámka

Viz také

Platí pro

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

genericParameterCount: Int32

Počet parametrů obecného typu metody.

types: Type[]

Pole Type objektů představující počet, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Pole ParameterModifier objektů představující atributy přidružené k odpovídajícímu prvku v types poli. Používá se pouze při volání prostřednictvím zprostředkovatele komunikace com a jsou zpracovávány pouze parametry, které jsou předány odkazem. Výchozí vázací objekt tento parametr nezpracovává.

Návraty

MethodInfo

Objekt představující veřejnou metodu, která odpovídá zadanému počtu obecných parametrů, typů argumentů a modifikátorů, pokud jsou nalezeny; v opačném případě . null

Výjimky

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types poli je null.

ArgumentException

genericParameterCount je negativní.

Platí pro

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

Zdroj:: 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

Parametry

name: String

genericParameterCount: Int32

bindingAttr: BindingFlags

types: Type[]

Návraty

MethodInfo

Platí pro

GetMethod(String, BindingFlags)

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu pomocí zadaných omezení vazby.

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

Parametry

name: String

Řetězec obsahující název metody, která má být získána.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují způsob provedení hledání.

-nebo-

Defaulta vrátí .null

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadaným požadavkům, pokud je nalezen; v opačném případě . null

Implementuje

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

Výjimky

AmbiguousMatchException

Byla nalezena více než jedna metoda se zadaným názvem, která odpovídá zadaným omezením vazby.

ArgumentNullException

name je null.

Příklady

Následující příklad získá metodu, která odpovídá zadaným příznakům vazby.

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

Poznámky

Následující BindingFlags příznaky filtru lze použít k definování metod, které se mají zahrnout do hledání:

Pokud chcete získat vrácení, musíte zadat nebo BindingFlags.Instance BindingFlags.Static .
Zadejte BindingFlags.Public , chcete-li do vyhledávání zahrnout veřejné metody.
Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuly neveřejné metody (tj. soukromé, interní a chráněné metody).
Zadejte BindingFlags.FlattenHierarchy , chcete-li zahrnout public a protected statické členy v hierarchii; private statické členy ve zděděných třídách nebudou zahrnuty.

Pomocí následujících BindingFlags příznaků modifikátoru můžete změnit způsob fungování vyhledávání:

BindingFlags.IgnoreCase pokud chcete ignorovat případ name.
BindingFlags.DeclaredOnly hledat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete v tématu System.Reflection.BindingFlags.

Pokud je metoda přetížena a více než jedno přetížení splňuje omezení určená argumentem bindingAttr , vyvolá metoda výjimku AmbiguousMatchException . V následujícím příkladu je vyvolání výjimky z následujících důvodů:

Typ TestClass má dvě přetížení DisplayValue veřejné instance metody DisplayValue(String) a DisplayValue(String, Object[]).
Typ TestClass má dvě přetížení Equals veřejné instance metody, z nichž jedno je zděděno z Object: Equals(TestClass) a 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)

Konkrétní metodu můžete načíst jedním z následujících způsobů:

Změňte omezení vazby. V předchozím příkladu se při pokusu o načtení metody veřejné instance Equals , která je deklarována typem a není zděděná, úspěšně načte Equals(TestClass).
Volání přetížení GetMethod metody, která obsahuje types parametr, který definuje typy parametrů metody.
GetMethods(BindingFlags) Voláním metody načtěte pole obsahující všechny metody patřící do typu, které mají zadané atributy vazby. Pak ho můžete iterovat a identifikovat duplicitní metody s názvem name. Tento přístup je znázorněn v obslužné rutině výjimky v předchozím příkladu AmbiguousMatchException .

Pokud aktuální Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda s parametry typu nahrazené argumenty příslušného typu.

Poznámka

Viz také

Platí pro

GetMethod(String, BindingFlags, Type[])

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů, pomocí zadaných vazeb omezení.

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

Parametry

name: String

Řetězec obsahující název metody, která má být získána.

bindingAttr: BindingFlags

Bitové kombinace hodnot výčtu, které určují způsob provedení hledání. -or- Ve výchozím nastavení se vrátí null.

types: Type[]

Pole Type objektů představující počet, pořadí a typ parametrů, které má metoda získat. -or- Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

Návraty

MethodInfo

Objekt představující metodu, která odpovídá zadaným požadavkům, pokud je nalezen; v opačném případě . null

Platí pro

GetMethod(String, Int32, Type[])

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

genericParameterCount: Int32

Počet parametrů obecného typu metody.

types: Type[]

Pole Type objektů představující počet, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

Návraty

MethodInfo

Objekt představující veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů, pokud jsou nalezeny; v opačném případě . null

Výjimky

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types poli je null.

ArgumentException

genericParameterCount je negativní.

Platí pro

GetMethod(String, Type[])

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

types: Type[]

Pole Type objektů představující počet, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

Návraty

MethodInfo

Objekt představující veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů, pokud jsou nalezeny; v opačném případě . null

Implementuje

GetMethod(String, Type[])

Výjimky

AmbiguousMatchException

Je nalezeno více než jedna metoda se zadaným názvem a zadanými parametry.

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types souboru je null.

ArgumentException

Pole types je multidimenzionální.

Příklady

Následující příklad najde konkrétní přetížení , MethodAurčující různé typy argumentů.

Poznámka

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /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

Následující příklad načte MethodInfo objekty, které představují Add metody negenerního typu ( ArrayList třída), otevřeného obecného typu ( List<T> třída) a uzavřeného obecného typu ( List(Of String) typ ).

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)

Příklad definuje metodu GetAddMethod , která načte příslušný MethodInfo objekt. Pokud chcete zadat types argument pro otevřený obecný typ, volá metodu Type.GetGenericArguments . Pokud chcete zadat types argument pro uzavřený obecný typ, načte hodnotu Type.GenericTypeArguments vlastnosti .

Poznámky

Při hledání se rozlišují name velká a malá písmena. Hledání zahrnuje metody veřejných statických a veřejných instancí.

Poznámka

Při hledání konstruktorů a metod nelze parametry vynechávat. Můžete je vynechat pouze při vyvolání.

Pokud aktuální Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda s parametry typu nahrazené argumenty příslušného typu.

Poznámka

Parametr name nemůže obsahovat argumenty typu. Kód jazyka C# GetMethod("MyGenericMethod<int>") například vyhledá metodu s textovým názvem "MyGenericMethod<int>", nikoli metodu s názvem MyGenericMethod , která má jeden obecný argument typu int. Místo toho použijte GetMethod("MyGenericMethod") s příslušným parametrem types v poli .

Viz také

Platí pro

GetMethod(String)

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá veřejnou metodu se zadaným názvem.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

Návraty

MethodInfo

Objekt, který představuje veřejnou metodu se zadaným názvem, pokud je nalezen; v opačném případě . null

Implementuje

GetMethod(String)

Výjimky

AmbiguousMatchException

Je nalezeno více než jedna metoda se zadaným názvem.

ArgumentNullException

name je null.

Příklady

Následující příklad získá metodu s názvem 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

Poznámky

Při hledání se rozlišují name velká a malá písmena. Hledání zahrnuje metody veřejných statických a veřejných instancí.

Pokud je metoda přetížena a má více než jednu veřejnou metodu GetMethod(String) , metoda vyvolá AmbiguousMatchException výjimku. V následujícím příkladu je vyvolán výjimka, protože existuje více než jedno veřejné přetížení Int32.ToString metody. Na druhou stranu, protože Person.ToString metoda přepisuje Object.ToString , a proto není přetížena, GetMethod(String) je metoda schopna MethodInfo načíst objekt.

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.

Konkrétní metodu můžete načíst jedním z následujících způsobů:

Zavolejte metodu GetMethod(String, BindingFlags) a zadejte bindingAttr argument, který metodu jednoznačně identifikuje. Pokud je například výjimka vyvoláná, protože typ má statické přetížení a přetížení instance, můžete zadat bindingAttr argument BindingFlags.InstanceOrBindingFlags.Instance.
Volání přetížení GetMethod metody, která obsahuje types parametr, který definuje typy parametrů metody.
GetMethods() Voláním metody načtete pole obsahující všechny veřejné metody, které patří do typu. Pak ho můžete iterovat a identifikovat duplicitní metody s názvem name.

Pokud aktuální Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda s parametry typu nahrazené argumenty příslušného typu.

Poznámka

Viz také

Platí pro

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

Zdroj:: Type.cs

Zdroj:: Type.cs

Zdroj:: Type.cs

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

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

Parametry

name: String

Řetězec obsahující název veřejné metody, která se má získat.

types: Type[]

Pole Type objektů představující počet, pořadí a typ parametrů, které má metoda získat.

-nebo-

Prázdné pole Type objektů (podle EmptyTypes pole) pro získání metody, která nepřijímá žádné parametry.

modifiers: ParameterModifier[]

Pole ParameterModifier objektů představující atributy přidružené k odpovídajícímu prvku v types poli. Používá se pouze při volání prostřednictvím zprostředkovatele komunikace com a jsou zpracovávány pouze parametry, které jsou předány odkazem. Výchozí vázací objekt tento parametr nezpracovává.

Návraty

MethodInfo

Objekt představující veřejnou metodu, která odpovídá zadaným požadavkům, pokud je nalezen; v opačném případě . null

Implementuje

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

Výjimky

AmbiguousMatchException

Je nalezeno více než jedna metoda se zadaným názvem a zadanými parametry.

ArgumentNullException

name je null.

-nebo-

types je null.

-nebo-

Jedním z prvků v types souboru je null.

ArgumentException

Pole types je multidimenzionální.

-nebo-

Pole modifiers je multidimenzionální.

Poznámky

I když výchozí pořadač nezpracovává ParameterModifier ( modifiers parametr), můžete použít abstraktní System.Reflection.Binder třídu k zápisu vlastního pořadače, který zpracovává modifiers. ParameterModifier se používá pouze při volání prostřednictvím zprostředkovatele komunikace com a jsou zpracovávány pouze parametry, které jsou předány odkazem.

Při hledání se rozlišují name velká a malá písmena. Hledání zahrnuje metody veřejných statických a veřejných instancí.

Poznámka

Při hledání konstruktorů a metod nelze parametry vynechávat. Můžete je vynechat pouze při vyvolání.

Pokud aktuální Type představuje konstruovaný obecný typ, vrátí MethodInfo tato metoda s parametry typu nahrazené argumenty příslušného typu.

Poznámka

U obecných metod nezahrnujte argumenty typu v namesouboru . Například kód GetMethod("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli metodu s názvem MyMethod , která má jeden obecný argument typu int. Místo toho použijte GetMethod("MyMethod") s příslušným parametrem types v poli .

Viz také

Platí pro

Sdílet prostřednictvím

Type.GetMethod Metoda

Definice

Přetížení

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

Parametry

Návraty

Výjimky

Platí pro

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

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Platí pro

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

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Platí pro

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

Parametry

Návraty

Platí pro

GetMethod(String, BindingFlags)

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

GetMethod(String, BindingFlags, Type[])

Parametry

Návraty

Platí pro

GetMethod(String, Int32, Type[])

Parametry

Návraty

Výjimky

Platí pro

GetMethod(String, Type[])

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

GetMethod(String)

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty