Type.GetMethod Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

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

Přetížení

Name	Description
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typů 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[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů, pomocí zadaných omezení vazby.
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

Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typů 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);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
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);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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í způsob provedení hledání.

nebo

Default nullvrátit .

binder

Binder

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

nebo

Nulový odkaz (Nothing v jazyce Visual Basic), který se má použít DefaultBinder.

callConvention

CallingConventions

Objekt, který určuje sadu pravidel, která se mají použít v souvislosti s pořadím a rozložením argumentů, jak se předá vrácená hodnota, jaké registry se používají pro argumenty a jak se zásobník vyčistí.

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

ArgumentNullException

name je null.

nebo

types je null.

nebo

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

ArgumentException

genericParameterCount je negativní.

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
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);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
member 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á se má získat.

bindingAttr

BindingFlags

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

nebo

Default nullvrátit .

binder

Binder

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

nebo

Nulový odkaz (Nothing v jazyce Visual Basic), který se má použít DefaultBinder.

callConvention

CallingConventions

Objekt, který určuje sadu pravidel, která se mají použít v souvislosti s pořadím a rozložením argumentů, jak se předá vrácená hodnota, jaké registry se používají pro argumenty a jak se zásobník vyčistí.

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Najde se více než jedna metoda se zadaným názvem a shoduje se se zadanými omezeními vazby.

ArgumentNullException

name je null.

nebo

types je null.

nebo

Jedním z prvků je typesnull.

ArgumentException

types je multidimenzionální.

nebo

modifiers je multidimenzionální.

Příklady

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

Poznámka:

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /unsafe .

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í přes COM interop a jsou zpracovávány pouze parametry předané odkazem.

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

Typ členu	Statický.	Nestatické
Konstruktor	Ne	Ne
Pole	Ne	Ano. Pole se vždy skryje podle názvu a signatury.
Zvláštní událost	Není relevantní	Běžné pravidlo systému typů je, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe považuje vlastnosti za skrýt podle názvu a podpisu. Viz poznámka 2 níže.
Metoda	Ne	Ano. Metodu (virtuální i ne virtuální) lze skrýt podle názvu nebo skrýt podle názvu a podpisu.
Vnořený typ	Ne	Ne
Vlastnictví	Není relevantní	Běžné pravidlo systému typů je, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe považuje vlastnosti za skrýt podle názvu a podpisu. Viz poznámka 2 níže.

1. Funkce skrytí podle jména a podpisu zohledňuje 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í.

2. Pro reflexi jsou vlastnosti a události skryty podle názvu a podpisu. Pokud máte vlastnost s oběma přístupovými metodami get i set v základní třídě, ale odvozená třída má pouze přístupovou metodu get, odvozená třída překryje vlastnost základní třídy a nebudete mít přístup k nastavovací metodě základní třídy.

3. Vlastní atributy nejsou součástí systému běžných typů.

BindingFlags Následující příznaky filtru lze použít k definování metod, které mají být zahrnuty do vyhledávání:

• Abyste získali vrácení, je nutné zadat buď BindingFlags.Instance nebo BindingFlags.Static.

• Zadejte BindingFlags.Public , aby byly do vyhledávání zahrnuty veřejné metody.

• Zadejte BindingFlags.NonPublic , aby do vyhledávání byly zahrnuty nepublikované metody (tj. soukromé, interní a chráněné metody).

• Určete BindingFlags.FlattenHierarchy, aby se zahrnuly public a protected statické členy v hierarchii; ale private statické členy v zděděných třídách nejsou zahrnuty.

Ke změně fungování vyhledávání můžete použít následující BindingFlags modifikační příznaky:

• BindingFlags.IgnoreCase ignorovat případ name.

• BindingFlags.DeclaredOnly hledat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete na System.Reflection.BindingFlags.

Poznámka:

Při vyhledávání konstruktorů a metod nelze vynechat parametry. Parametry můžete vynechat pouze při vyvolání.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Pro obecné metody nezahrnujte argumenty typu do name. Například kód GetMember("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli pro metodu s názvem MyMethod , která má jeden obecný argument typu int.

Viz také

• MethodInfo
• String
• BindingFlags
• Binder
• DefaultBinder
• CallingConventions
• ParameterModifier
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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í způsob provedení hledání.

nebo

Default nullvrátit .

binder

Binder

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

nebo

Nulový odkaz (Nothing v jazyce Visual Basic), který se má použít DefaultBinder.

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

ArgumentNullException

name je null.

nebo

types je null.

nebo

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

ArgumentException

genericParameterCount je negativní.

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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á se má získat.

bindingAttr

BindingFlags

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

nebo

Default nullvrátit .

binder

Binder

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

nebo

Nulový odkaz (Nothing v jazyce Visual Basic), který se má použít DefaultBinder.

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

Návraty

MethodInfo

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

Implementuje

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

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Najde se více než jedna metoda se zadaným názvem a shoduje se se zadanými omezeními vazby.

ArgumentNullException

name je null.

nebo

types je null.

nebo

Jedním z prvků je typesnull.

ArgumentException

types je multidimenzionální.

nebo

modifiers je multidimenzionální.

Příklady

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

Poznámka:

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /unsafe .

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

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í přes COM interop a jsou zpracovávány pouze parametry předané odkazem.

BindingFlags Následující příznaky filtru lze použít k definování metod, které mají být zahrnuty do vyhledávání:

• Abyste získali vrácení, je nutné zadat buď BindingFlags.Instance nebo BindingFlags.Static.

• Zadejte BindingFlags.Public , aby byly do vyhledávání zahrnuty veřejné metody.

• Zadejte BindingFlags.NonPublic , aby do vyhledávání byly zahrnuty nepublikované metody (tj. soukromé, interní a chráněné metody).

• Určete BindingFlags.FlattenHierarchy, aby se zahrnuly public a protected statické členy v hierarchii; ale private statické členy v zděděných třídách nejsou zahrnuty.

Ke změně fungování vyhledávání můžete použít následující BindingFlags modifikační příznaky:

• BindingFlags.IgnoreCase ignorovat případ name.

• BindingFlags.DeclaredOnly hledat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete na System.Reflection.BindingFlags.

Poznámka:

Při vyhledávání konstruktorů a metod nelze vynechat parametry. Parametry můžete vynechat pouze při vyvolání.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Pro obecné metody nezahrnujte argumenty typu do name. Například kód GetMember("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli pro metodu s názvem MyMethod , která má jeden obecný argument typu int.

Viz také

• MethodInfo
• String
• BindingFlags
• Binder
• DefaultBinder
• ParameterModifier
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, int genericParameterCount, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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 objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

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ům, pokud jsou nalezeny; v opačném případě . null

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

ArgumentNullException

name je null.

nebo

types je null.

nebo

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

ArgumentException

genericParameterCount je negativní.

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

Zdroj:

Type.cs

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, cli::array <Type ^> ^ types);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, Type[] types);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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

Řetězec obsahující název 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í způsob provedení hledání.

nebo

Default nullvrátit .

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k získání metody, která nepřijímá žádné parametry.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

GetMethod(String, BindingFlags)

Zdroj:

Type.cs

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

public:
 virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, System.Reflection.BindingFlags bindingAttr);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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á se má získat.

bindingAttr

BindingFlags

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

nebo

Default nullvrátit .

Návraty

MethodInfo

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

Implementuje

GetMethod(String, BindingFlags)

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Najde se více než jedna metoda se zadaným názvem a shoduje se se zadanými omezeními 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 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

BindingFlags Následující příznaky filtru lze použít k definování metod, které mají být zahrnuty do vyhledávání:

• Abyste získali vrácení, je nutné zadat buď BindingFlags.Instance nebo BindingFlags.Static.

• Zadejte BindingFlags.Public , aby byly do vyhledávání zahrnuty veřejné metody.

• Zadejte BindingFlags.NonPublic , aby do vyhledávání byly zahrnuty neveřejné metody (tj. soukromé, interní a chráněné metody).

• Určete BindingFlags.FlattenHierarchy, aby se zahrnuly public a protected statické členy v hierarchii; ale private statické členy v zděděných třídách nejsou zahrnuty.

Ke změně fungování vyhledávání můžete použít následující BindingFlags modifikační příznaky:

• BindingFlags.IgnoreCase ignorovat případ name.

• BindingFlags.DeclaredOnly hledat pouze metody deklarované na Type, nikoli metody, které byly jednoduše zděděny.

Další informace naleznete na System.Reflection.BindingFlags.

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

• 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ž jedna je zděděna 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)

Pokud chcete načíst konkrétní metodu, můžete provést jednu z následujících věcí:

• Změňte omezení vazby. V předchozím příkladu se pokoušíte načíst metodu veřejné instance Equals , která je deklarována typem a neděděna ú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í k typu, který má zadané atributy vazby. Pak ji můžete iterovat a identifikovat duplicitní metody pojmenované name. Tento přístup je znázorněn v obslužné rutině předchozího příkladu AmbiguousMatchException výjimky.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Pro obecné metody nezahrnujte argumenty typu do name. Například kód GetMember("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli pro metodu s názvem MyMethod , která má jeden obecný argument typu int.

Viz také

• MethodInfo
• String
• BindingFlags
• DefaultBinder
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()

GetMethod(String, BindingFlags, Type[])

Zdroj:

Type.cs

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, System::Reflection::BindingFlags bindingAttr, cli::array <Type ^> ^ types);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, System.Reflection.BindingFlags bindingAttr, Type[] types);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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á se má získat.

bindingAttr

BindingFlags

Bitové kombinace hodnot výčtu, které určují způsob provedení hledání. -nebo- Výchozí hodnota, která se má vrátit null.

types

Type[]

Pole objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat. -or- Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) získat metodu, která nepřijímá žádné parametry.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

GetMethod(String, Int32, Type[])

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, int genericParameterCount, Type[] types);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
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 objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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 obecnému počtu parametrů a typům argumentů, pokud jsou nalezeny; v opačném případě . null

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

ArgumentNullException

name je null.

nebo

types je null.

nebo

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

ArgumentException

genericParameterCount je negativní.

GetMethod(String, Type[])

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, Type[] types);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
member 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 objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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 byly nalezeny; v opačném případě . null

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Najde se 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ů je typesnull.

ArgumentException

types je multidimenzionální.

Příklady

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

Poznámka:

Příklad Visual C# 2005 vyžaduje možnost kompilátoru /unsafe .

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 ne generického typu ( ArrayList třída), otevřený obecný typ ( List<T> třída) a uzavřený obecný typ ( 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. Chcete-li zadat types argument pro otevřený obecný typ, volá metodu Type.GetGenericArguments . Chcete-li zadat types argument pro uzavřený obecný typ, načte hodnotu Type.GenericTypeArguments vlastnosti.

Poznámky

Hledání pro name rozlišuje malá a velká písmena. Hledání zahrnuje veřejné statické a veřejné metody instance.

Poznámka:

Při vyhledávání konstruktorů a metod nelze vynechat parametry. Parametry můžete vynechat pouze při vyvolání.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Parametr name nemůže obsahovat argumenty typu. Například kód GetMethod("MyGenericMethod<int>") jazyka C# vyhledá metodu s textovým názvem "MyGenericMethod<int>", nikoli pro metodu s názvem MyGenericMethod , která má jeden obecný argument typu int. Místo toho použijte GetMethod("MyGenericMethod") odpovídající parametr v types poli.

Viz také

• MethodInfo
• DefaultBinder
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()

GetMethod(String)

Zdroj:

Type.cs

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
member 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 byl nalezen; v opačném případě . null

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Existuje 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 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

Hledání pro name rozlišuje malá a velká písmena. Hledání zahrnuje veřejné statické a veřejné metody instance.

Pokud je metoda přetížená a má více než jednu veřejnou metodu, GetMethod(String) vyvolá metoda 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řepíše Object.ToString a proto není přetížena, GetMethod(String) metoda je schopna načíst MethodInfo 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.

Pokud chcete načíst konkrétní metodu, můžete provést jednu z následujících věcí:

• Zavolejte metodu GetMethod(String, BindingFlags)bindingAttr a zadejte argument, který jednoznačně identifikuje metodu. Pokud je například vyvolán výjimka, protože typ má statickou a přetížení instance, můžete zadat bindingAttr argument nebo BindingFlags.StaticBindingFlags.Instance.

• Volání přetížení GetMethod metody, která obsahuje types parametr, který definuje typy parametrů metody.

• GetMethods() Volání metody k načtení pole obsahující všechny veřejné metody patřící do typu. Pak ji můžete iterovat a identifikovat duplicitní metody pojmenované name.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Pro obecné metody nezahrnujte argumenty typu do name. Například kód GetMember("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli pro metodu s názvem MyMethod , která má jeden obecný argument typu int.

Viz také

• MethodInfo
• String
• DefaultBinder
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
public System.Reflection.MethodInfo? GetMethod(string name, Type[] types, System.Reflection.ParameterModifier[]? modifiers);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)>]
member 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 objektů představujících Type číslo, pořadí a typ parametrů pro metodu získat.

nebo

Prázdné pole Type objektů (jak je poskytováno EmptyTypes polem) k 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. Chcete-li použít pouze při volání prostřednictvím zprostředkovatele komunikace modelu COM a zpracovávají se pouze parametry, které jsou předány odkazem. Výchozí pořadač tento parametr nezpracuje.

Návraty

MethodInfo

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

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

AmbiguousMatchException

Najde se 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ů je typesnull.

ArgumentException

types je multidimenzionální.

nebo

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í přes COM interop a jsou zpracovávány pouze parametry předané odkazem.

Hledání pro name rozlišuje malá a velká písmena. Hledání zahrnuje veřejné statické a veřejné metody instance.

Poznámka:

Při vyhledávání konstruktorů a metod nelze vynechat parametry. Parametry můžete vynechat pouze při vyvolání.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí MethodInfo s parametry typu nahrazené odpovídajícími argumenty typu.

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

Poznámka:

Pro obecné metody nezahrnujte argumenty typu do name. Například kód GetMethod("MyMethod<int>") jazyka C# vyhledá člena s textovým názvem "MyMethod<int>", nikoli pro metodu s názvem MyMethod , která má jeden obecný argument typu int. Místo toho použijte GetMethod("MyMethod") odpovídající parametr v types poli.

Viz také

• MethodInfo
• String
• DefaultBinder
• ParameterModifier
• GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])
• GetMethods()