Type.GetMethod Type.GetMethod Type.GetMethod Type.GetMethod Method

Definizione

Ottiene un metodo specifico dell'oggetto Type corrente.Gets a specific method of the current Type.

Overload

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

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

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

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints.

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

Cerca il metodo pubblico specificato i cui parametri corrispondono ai tipi di argomenti specificati.Searches for the specified public method whose parameters match the specified argument types.

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

Cerca il metodo specificato, usando i vincoli di binding specificati.Searches for the specified method, using the specified binding constraints.

GetMethod(String) GetMethod(String) GetMethod(String) GetMethod(String)

Cerca il metodo pubblico con il nome specificato.Searches for the public method with the specified name.

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

Cerca il metodo pubblico specificato i cui parametri corrispondono ai modificatori e ai tipi di argomenti specificati.Searches for the specified public method whose parameters match the specified argument types and modifiers.

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, System::Reflection::CallingConventions callConvention, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * int * System.Reflection.BindingFlags * System.Reflection.Binder * System.Reflection.CallingConventions * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo

Parametri

genericParameterCount
Int32 Int32 Int32 Int32
types
Type[]
modifiers
ParameterModifier[]

Restituisce

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

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

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

Parametri

name
String String String String

Stringa che contiene il nome del metodo da ottenere.The string containing the name of the method to get.

bindingAttr
BindingFlags BindingFlags BindingFlags BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la ricerca.A bitwise combination of the enumeration values that specify how the search is conducted.

-oppure--or- Default per restituire null.Default to return null.

binder
Binder Binder Binder Binder

Oggetto che definisce una serie di proprietà e permette il binding, che può implicare la scelta di un metodo di overload, la coercizione di tipi di argomento e la chiamata di un membro mediante reflection.An object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-oppure--or- Riferimento Null (Nothing in Visual Basic) per l'uso di DefaultBinder.A null reference (Nothing in Visual Basic), to use the DefaultBinder.

callConvention
CallingConventions CallingConventions CallingConventions CallingConventions

Oggetto che specifica il set di regole da usare per la disposizione e il layout degli argomenti, la modalità di passaggio del valore restituito, i registri usati per gli argomenti e la pulizia dello stack.The object that specifies the set of rules to use regarding the order and layout of arguments, how the return value is passed, what registers are used for arguments, and how the stack is cleaned up.

types
Type[]

Matrice di oggetti Type che rappresentano numero, ordine e tipo dei parametri relativi al metodo da ottenere.An array of Type objects representing the number, order, and type of the parameters for the method to get.

-oppure--or- Matrice vuota di oggetti Type (come fornita dal campo EmptyTypes) per ottenere un metodo che non accetta parametri.An empty array of Type objects (as provided by the EmptyTypes field) to get a method that takes no parameters.

modifiers
ParameterModifier[]

Matrice di oggetti ParameterModifier che rappresentano gli attributi associati all'elemento corrispondente nella matrice types.An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. Da usare solo quando si effettuano chiamate tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.To be only used when calling through COM interop, and only parameters that are passed by reference are handled. Questo parametro non viene elaborato dal binder predefinito.The default binder does not process this parameter.

Restituisce

Oggetto che rappresenta il metodo corrispondente ai requisiti specificati, se presente; in caso contrario, null.An object representing the method that matches the specified requirements, if found; otherwise, null.

Implementazioni

Eccezioni

È stato trovato più di un metodo con il nome specificato e corrispondente ai vincoli di associazione specificati.More than one method is found with the specified name and matching the specified binding constraints.

name è null.name is null.

-oppure--or- types è null.types is null.

-oppure--or- Uno degli elementi in types è null.One of the elements in types is null.

types è multidimensionale.types is multidimensional.

In alternativa-or- modifiers è multidimensionale.modifiers is multidimensional.

Esempi

Nell'esempio seguente vengono individuati overload specifici di MethodA, specificando vincoli di binding, convenzioni di chiamata e vari tipi di argomento.The following example finds specific overloads of MethodA, specifying binding constraints, calling conventions, and a variety of argument types.

Nota

Per Visual C# 2005Visual C# 2005 l'esempio è /unsafe necessaria l'opzione del compilatore.The Visual C# 2005Visual C# 2005 example requires the /unsafe compiler option.

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 Program
{
    // Methods to get:

    public void MethodA(int i, int j) { }

    public void MethodA(int[] i) { }

    public unsafe void MethodA(int* i) { }

    public void MethodA(ref int r) {}

    // Method that takes an out parameter:
    public void MethodA(int i, out int o) { o = 100;}


  static void Main(string[] args)
  {
    MethodInfo mInfo;

    // Get MethodA(int i, int j)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        new Type[] { typeof(int), typeof(int) },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int[] i)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        new Type[] { typeof(int[]) },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int* i)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        new Type[] { typeof(int).MakePointerType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(ref int r)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        new Type[] { typeof(int).MakeByRefType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int i, out int o)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        new Type[] { typeof(int), typeof(int).MakeByRefType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

  }
}

Imports System.Reflection
Imports System.Runtime.InteropServices

Class Program

    ' Methods to get:
    
    Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)

    End Sub

    Public Overloads Sub MethodA(ByVal i() As Integer)

    End Sub

    Public Overloads Sub MethodA(ByRef r As Integer)

    End Sub

    ' Method that takes an integer and an out parameter. Note that an
    ' Imports reference is needed to System.Runtime.InteropServices
    ' for the <OutAttribute>, which can be shortened to <Out>.
    Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
        o = 100
    End Sub

    Public Shared Sub Main(ByVal args() As String)
        Dim mInfo As MethodInfo

        ' Get MethodA(ByVal i As Integer, ByVal l As Long)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            CallingConventions.Any, _
            New Type() {GetType(System.Int32), _
            GetType(System.Int64)}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get  MethodA(ByVal i() As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            CallingConventions.Any, _
            New Type() {GetType(System.Int32())}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByRef r As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
        BindingFlags.Public Or BindingFlags.Instance, _
        Nothing, _
        CallingConventions.Any, _
        New Type() {GetType(System.Int32).MakeByRefType}, _
        Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
        BindingFlags.Public Or BindingFlags.Instance, _
        Nothing, _
        CallingConventions.Any, _
        New Type() {GetType(System.Int32), GetType(System.Int32).MakeByRefType}, _
        Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

    End Sub
End Class

Commenti

Sebbene il Binder ParameterModifier predefinito non elabori (il modifiers parametro), è possibile usare la classe astratta System.Reflection.Binder per scrivere un gestore di associazione personalizzato che esegue modifiersl'elaborazione.Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract System.Reflection.Binder class to write a custom binder that does process modifiers. ParameterModifierviene utilizzato solo quando si effettua una chiamata tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

La tabella seguente mostra quali membri di una classe di base vengono restituiti dai GetXXX metodi durante la reflection su un tipo.The following table shows what members of a base class are returned by the GetXXX methods when reflecting on a type.

Tipo di membroMember Type StaticStatic Non staticoNon-Static
CostruttoreConstructor NoNo NoNo
CampoField NoNo Sì.Yes. Un campo è sempre nascosto per nome e firma.A field is always hide-by-name-and-signature.
eventEvent Non applicabileNot applicable La regola Common Type System è che l'ereditarietà è identica a quella dei metodi che implementano la proprietà.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflection considera le proprietà come nascoste per nome e firma.Reflection treats properties as hide-by-name-and-signature. Vedere la nota 2 di seguito.See note 2 below.
MetodoMethod NoNo Sì.Yes. Un metodo (sia virtuale che non virtuale) può essere nascosto in base al nome o nascosto per nome e firma.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo annidatoNested Type NoNo NoNo
ProprietàProperty Non applicabileNot applicable La regola Common Type System è che l'ereditarietà è identica a quella dei metodi che implementano la proprietà.The common type system rule is that the inheritance is the same as that of the methods that implement the property. La reflection considera le proprietà come nascoste per nome e firma.Reflection treats properties as hide-by-name-and-signature. Vedere la nota 2 di seguito.See note 2 below.
  1. Hide-by-Name-and-signature prende in considerazione tutte le parti della firma, inclusi i modificatori personalizzati, i tipi restituiti, i tipi di parametro, le sentinelle e le convenzioni di chiamata non gestite.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Si tratta di un confronto binario.This is a binary comparison.

  2. Per la reflection, le proprietà e gli eventi sono nascosti per nome e firma.For reflection, properties and events are hide-by-name-and-signature. Se si dispone di una proprietà con una funzione di accesso get e set nella classe di base, ma la classe derivata dispone solo di una funzione di accesso get, la proprietà della classe derivata nasconde la proprietà della classe base e non sarà possibile accedere al setter sulla classe di base.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Gli attributi personalizzati non fanno parte del Common Type System.Custom attributes are not part of the common type system.

I flag BindingFlags di filtro seguenti possono essere usati per definire i metodi da includere nella ricerca:The following BindingFlags filter flags can be used to define which methods to include in the search:

  • È necessario specificare BindingFlags.Instance o BindingFlags.Static per ottenere un valore restituito.You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.

  • Specificare BindingFlags.Public per includere i metodi pubblici nella ricerca.Specify BindingFlags.Public to include public methods in the search.

  • Specificare BindingFlags.NonPublic per includere metodi non pubblici (ovvero metodi privati, interni e protetti) nella ricerca.Specify BindingFlags.NonPublic to include nonpublic methods (that is, private, internal, and protected methods) in the search.

  • Consente BindingFlags.FlattenHierarchy di specificare public la protected gerarchia per includere i membri statici. private i membri statici nelle classi ereditate non sono inclusi.Specify BindingFlags.FlattenHierarchy to include public and protected static members up the hierarchy; private static members in inherited classes are not included.

I flag BindingFlags di modifica seguenti possono essere utilizzati per modificare il funzionamento della ricerca:The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.IgnoreCaseper ignorare la distinzione tra namemaiuscole e minuscole.BindingFlags.IgnoreCase to ignore the case of name.

  • BindingFlags.DeclaredOnlyper eseguire la ricerca solo nei metodi dichiarati in Type, non nei metodi semplicemente ereditati.BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

Per altre informazioni, vedere System.Reflection.BindingFlags.See System.Reflection.BindingFlags for more information.

Nota

Non è possibile omettere i parametri durante la ricerca di costruttori e metodi.You cannot omit parameters when looking up constructors and methods. È possibile omettere solo i parametri quando si richiama.You can only omit parameters when invoking.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Per i metodi generici, non includere gli argomenti di nametipo in.For generic methods, do not include the type arguments in name. Ad esempio, il C# codice GetMember("MyMethod<int>") Cerca un membro con il nome di testo "MyMethod<int>", anziché per un metodo denominato MyMethod con un argomento generico di tipo int.For example, the C# code GetMember("MyMethod<int>") searches for a member with the text name "MyMethod<int>", rather than for a method named MyMethod that has one generic argument of type int.

Vedi anche

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, Type[] types, System.Reflection.ParameterModifier[] modifiers);
member this.GetMethod : string * int * System.Reflection.BindingFlags * System.Reflection.Binder * Type[] * System.Reflection.ParameterModifier[] -> System.Reflection.MethodInfo

Parametri

genericParameterCount
Int32 Int32 Int32 Int32
types
Type[]
modifiers
ParameterModifier[]

Restituisce

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

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints.

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

Parametri

name
String String String String

Stringa che contiene il nome del metodo da ottenere.The string containing the name of the method to get.

bindingAttr
BindingFlags BindingFlags BindingFlags BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la ricerca.A bitwise combination of the enumeration values that specify how the search is conducted.

-oppure--or- Default per restituire null.Default to return null.

binder
Binder Binder Binder Binder

Oggetto che definisce una serie di proprietà e permette il binding, che può implicare la scelta di un metodo di overload, la coercizione di tipi di argomento e la chiamata di un membro mediante reflection.An object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-oppure--or- Riferimento Null (Nothing in Visual Basic) per l'uso di DefaultBinder.A null reference (Nothing in Visual Basic), to use the DefaultBinder.

types
Type[]

Matrice di oggetti Type che rappresentano numero, ordine e tipo dei parametri relativi al metodo da ottenere.An array of Type objects representing the number, order, and type of the parameters for the method to get.

In alternativa-or- Matrice vuota di oggetti Type (come fornita dal campo EmptyTypes) per ottenere un metodo che non accetta parametri.An empty array of Type objects (as provided by the EmptyTypes field) to get a method that takes no parameters.

modifiers
ParameterModifier[]

Matrice di oggetti ParameterModifier che rappresentano gli attributi associati all'elemento corrispondente nella matrice types.An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. Da usare solo quando si effettuano chiamate tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.To be only used when calling through COM interop, and only parameters that are passed by reference are handled. Questo parametro non viene elaborato dal binder predefinito.The default binder does not process this parameter.

Restituisce

Oggetto che rappresenta il metodo corrispondente ai requisiti specificati, se presente; in caso contrario, null.An object representing the method that matches the specified requirements, if found; otherwise, null.

Implementazioni

Eccezioni

È stato trovato più di un metodo con il nome specificato e corrispondente ai vincoli di associazione specificati.More than one method is found with the specified name and matching the specified binding constraints.

name è null.name is null.

-oppure--or- types è null.types is null.

In alternativa-or- Uno degli elementi in types è null.One of the elements in types is null.

types è multidimensionale.types is multidimensional.

-oppure--or- modifiers è multidimensionale.modifiers is multidimensional.

Esempi

Nell'esempio seguente vengono trovati overload specifici di MethodA, specificando vincoli di binding e una serie di tipi di argomento.The following example finds specific overloads of MethodA, specifying binding constraints and a variety of argument types.

Nota

Per Visual C# 2005Visual C# 2005 l'esempio è /unsafe necessaria l'opzione del compilatore.The Visual C# 2005Visual C# 2005 example requires the /unsafe compiler option.

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 Program
{
    // Methods to get:

    public void MethodA(int i, int j) { }

    public void MethodA(int[] i) { }

    public unsafe void MethodA(int* i) { }


    public void MethodA(ref int r) {}

    // Method that takes an out parameter.
    public void MethodA(int i, out int o) { o = 100; }


  static void Main(string[] args)
  {
    MethodInfo mInfo;

    // Get MethodA(int i, int j)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int), typeof(int) },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int[] i)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int[]) },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int* i)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int).MakePointerType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(ref int r)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int).MakeByRefType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int i, out int o)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int), typeof(int).MakeByRefType() },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

  }
}

Imports System.Reflection
Imports System.Runtime.InteropServices

Class Program

    ' Methods to get:
    
    Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)

    End Sub

    Public Overloads Sub MethodA(ByVal i() As Integer)

    End Sub

    Public Overloads Sub MethodA(ByRef r As Integer)

    End Sub

    ' Method that takes an out parameter. Note that an Imports
    ' reference is needed to System.Runtime.InteropServices 
    ' for the <OutAttribute>, which can be shortened to <Out>.
    Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
        o = 100
    End Sub

    Public Shared Sub Main(ByVal args() As String)
        Dim mInfo As MethodInfo

        ' Get MethodA(ByVal i As Integer, ByVal l As Long)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            New Type() {GetType(System.Int32), _
            GetType(System.Int64)}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByVal i() As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            New Type() {GetType(System.Int32())}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByRef r As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            New Type() {GetType(System.Int32).MakeByRefType}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", _
            BindingFlags.Public Or BindingFlags.Instance, _
            Nothing, _
            New Type() {GetType(System.Int32), GetType(System.Int32).MakeByRefType}, _
            Nothing)
        Console.WriteLine("Found method: {0}", mInfo)

    End Sub
End Class

Commenti

Sebbene il Binder ParameterModifier predefinito non elabori (il modifiers parametro), è possibile usare la classe astratta System.Reflection.Binder per scrivere un gestore di associazione personalizzato che esegue modifiersl'elaborazione.Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract System.Reflection.Binder class to write a custom binder that does process modifiers. ParameterModifierviene utilizzato solo quando si effettua una chiamata tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

I flag BindingFlags di filtro seguenti possono essere usati per definire i metodi da includere nella ricerca:The following BindingFlags filter flags can be used to define which methods to include in the search:

  • È necessario specificare BindingFlags.Instance o BindingFlags.Static per ottenere un valore restituito.You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.

  • Specificare BindingFlags.Public per includere i metodi pubblici nella ricerca.Specify BindingFlags.Public to include public methods in the search.

  • Specificare BindingFlags.NonPublic per includere metodi non pubblici (ovvero metodi privati, interni e protetti) nella ricerca.Specify BindingFlags.NonPublic to include nonpublic methods (that is, private, internal, and protected methods) in the search.

  • Consente BindingFlags.FlattenHierarchy di specificare public la protected gerarchia per includere i membri statici. private i membri statici nelle classi ereditate non sono inclusi.Specify BindingFlags.FlattenHierarchy to include public and protected static members up the hierarchy; private static members in inherited classes are not included.

I flag BindingFlags di modifica seguenti possono essere utilizzati per modificare il funzionamento della ricerca:The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.IgnoreCaseper ignorare la distinzione tra namemaiuscole e minuscole.BindingFlags.IgnoreCase to ignore the case of name.

  • BindingFlags.DeclaredOnlyper eseguire la ricerca solo nei metodi dichiarati in Type, non nei metodi semplicemente ereditati.BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

Per altre informazioni, vedere System.Reflection.BindingFlags.See System.Reflection.BindingFlags for more information.

Nota

Non è possibile omettere i parametri durante la ricerca di costruttori e metodi.You cannot omit parameters when looking up constructors and methods. È possibile omettere solo i parametri quando si richiama.You can only omit parameters when invoking.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Per i metodi generici, non includere gli argomenti di nametipo in.For generic methods, do not include the type arguments in name. Ad esempio, il C# codice GetMember("MyMethod<int>") Cerca un membro con il nome di testo "MyMethod<int>", anziché per un metodo denominato MyMethod con un argomento generico di tipo int.For example, the C# code GetMember("MyMethod<int>") searches for a member with the text name "MyMethod<int>", rather than for a method named MyMethod that has one generic argument of type int.

Vedi anche

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, cli::array <Type ^> ^ types, cli::array <System::Reflection::ParameterModifier> ^ modifiers);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, Type[] types, System.Reflection.ParameterModifier[] modifiers);
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

Parametri

genericParameterCount
Int32 Int32 Int32 Int32
types
Type[]
modifiers
ParameterModifier[]

Restituisce

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

Cerca il metodo pubblico specificato i cui parametri corrispondono ai tipi di argomenti specificati.Searches for the specified public method whose parameters match the specified argument types.

public:
 virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo GetMethod (string name, Type[] types);
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

Parametri

name
String String String String

Stringa che contiene il nome del metodo pubblico da ottenere.The string containing the name of the public method to get.

types
Type[]

Matrice di oggetti Type che rappresentano numero, ordine e tipo dei parametri relativi al metodo da ottenere.An array of Type objects representing the number, order, and type of the parameters for the method to get.

-oppure--or- Matrice vuota di oggetti Type (come fornita dal campo EmptyTypes) per ottenere un metodo che non accetta parametri.An empty array of Type objects (as provided by the EmptyTypes field) to get a method that takes no parameters.

Restituisce

Oggetto che rappresenta il metodo pubblico i cui parametri corrispondono ai tipi di argomenti specificati, se è stato trovato; in caso contrario, null.An object representing the public method whose parameters match the specified argument types, if found; otherwise, null.

Implementazioni

Eccezioni

Sono stati trovati più metodi con il nome e i parametri specificati.More than one method is found with the specified name and specified parameters.

name è null.name is null.

-oppure--or- types è null.types is null.

-oppure--or- Uno degli elementi in types è null.One of the elements in types is null.

types è multidimensionale.types is multidimensional.

Esempi

Nell'esempio seguente vengono trovati overload specifici di MethodA, specificando un'ampia gamma di tipi di argomento.The following example finds specific overloads of MethodA, specifying a variety of argument types.

Nota

Per Visual C# 2005Visual C# 2005 l'esempio è /unsafe necessaria l'opzione del compilatore.The Visual C# 2005Visual C# 2005 example requires the /unsafe compiler option.

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 Program
{
    // Methods to get:

    public void MethodA(int i, int j) { }

    public void MethodA(int[] i) { }

    public unsafe void MethodA(int* i) { }

    public void MethodA(ref int r) {}

    // Method that takes an out parameter:
    public void MethodA(int i, out int o) { o = 100;}


  static void Main(string[] args)
  {
    MethodInfo mInfo;

    // Get MethodA(int i, int i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int), typeof(int) });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int[] i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int[]) });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int* i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int).MakePointerType() });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(ref int r)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int).MakeByRefType() });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int i, out int o)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int), typeof(int).MakeByRefType() });
    Console.WriteLine("Found method: {0}", mInfo);

  }
}

Imports System.Reflection
Imports System.Runtime.InteropServices

Class Program

    ' Methods to get:

    Public Overloads Sub MethodA(ByVal i As Integer, ByVal l As Long)

    End Sub

    Public Overloads Sub MethodA(ByVal i() As Integer)

    End Sub

    Public Overloads Sub MethodA(ByRef r As Integer)

    End Sub

    ' Method that takes an out parameter. Note that an Imports
    ' reference is needed to System.Runtime.InteropServices 
    ' for the <OutAttribute>, which can be shortened to <Out>.
    Public Overloads Sub MethodA(ByVal i As Integer, <Out()> ByRef o As Integer)
        o = 100
    End Sub

    Public Shared Sub Main(ByVal args() As String)
        Dim mInfo As MethodInfo

        ' Get MethodA(i As Integer i, l As Long)
        mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer), GetType(Long)})
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get  MethodA(i As Integer())
        mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer())})
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(ByRef r As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer).MakeByRefType})
        Console.WriteLine("Found method: {0}", mInfo)

        ' Get MethodA(i As Integer, ByRef r As Integer)
        mInfo = GetType(Program).GetMethod("MethodA", New Type() {GetType(Integer), _
            GetType(Integer).MakeByRefType})
        Console.WriteLine("Found method: {0}", mInfo)

    End Sub
End Class

Nell'esempio seguente vengono MethodInfo recuperati oggetti che Add rappresentano i metodi di un tipo non generico ( ArrayList la classe), un tipo generico aperto ( List<T> la classe) e un tipo generico chiuso (il List(Of String) tipo).The following example retrieves MethodInfo objects that represent the Add methods of a non-generic type (the ArrayList class), an open generic type (the List<T> class), and a closed generic type (the List(Of String) type.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get a Type object that represents a non-generic type.
      GetAddMethod(typeof(ArrayList));

      var list = new List<String>();
      // Get a Type object that represents a constructed generic type.
      Type closed = list.GetType();
      GetAddMethod(closed);
      
      // Get a Type object that represents an open generic type.
      Type open = typeof(List<>);
      GetAddMethod(open);
   }

   private static void GetAddMethod(Type typ)
   {
      MethodInfo method;
      // Determine if this is a generic type.
      if (typ.IsGenericType) {
         // Is it an open generic type?
         if (typ.ContainsGenericParameters)
            method = typ.GetMethod("Add", typ.GetGenericArguments());
         // Get closed generic type arguments.
         else
            method = typ.GetMethod("Add", typ.GenericTypeArguments);
      }
      // This is not a generic type.
      else {
         method = typ.GetMethod("Add", new Type[] { typeof(Object) } );
      }

      // Test if an Add method was found.
      if (method == null) { 
         Console.WriteLine("No Add method found.");
         return;
      }   
      
      Type t = method.ReflectedType;
      Console.Write("{0}.{1}.{2}(", t.Namespace, t.Name, method.Name);
      ParameterInfo[] parms = method.GetParameters();
      for (int ctr = 0; ctr < parms.Length; ctr++)
         Console.Write("{0}{1}", parms[ctr].ParameterType.Name, 
                       ctr < parms.Length - 1 ? ", " : "");

      Console.WriteLine(")");
   }   
}
// The example displays the following output:
//       System.Collections.ArrayList.Add(Object)
//       System.Collections.Generic.List`1.Add(String)
//       System.Collections.Generic.List`1.Add(T)
Imports System.Collections
Imports System.Collections.Generic
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get a Type object that represents a non-generic type.
      GetAddMethod(GetType(ArrayList))
      
      Dim list As New List(Of String)()
      ' Get a Type object that represents a constructed generic type.
      Dim closed As Type = list.GetType()
      GetAddMethod(closed)
      
      ' Get a Type object that represents an open generic type.
      Dim open As Type = GetType(List(Of))
      GetAddMethod(open)
   End Sub
   
   Private Sub GetAddMethod(typ As Type)
      Dim method As MethodInfo
      ' Determine if this is a generic type.
      If typ.IsGenericType Then
         ' Is it an open generic type?
         If typ.ContainsGenericParameters Then
            method = typ.GetMethod("Add", typ.GetGenericArguments())
         ' Get closed generic type arguments.
         Else
            method = typ.GetMethod("Add", typ.GenericTypeArguments)
         End If
      ' This is not a generic type.
      Else
         method = typ.GetMethod("Add", { GetType(Object) } )
      End If
      ' Test if an Add method was found.
      If method Is Nothing Then 
         Console.WriteLine("No Add method found.")
         Exit Sub
      End If   

      Dim t As Type = method.ReflectedType
      Console.Write("{0}.{1}.{2}(", t.Namespace, t.Name, method.Name)
      Dim params() As ParameterInfo = method.GetParameters()
      For ctr As Integer = 0 To params.Length - 1
         Console.Write("{0}{1}", params(ctr).ParameterType.Name, 
                       If(ctr < params.Length - 1, ", ", ""))
      Next
      Console.WriteLine(")")
   End Sub
End Module
' The example displays the following output:
'       System.Collections.ArrayList.Add(Object)
'       System.Collections.Generic.List`1.Add(String)
'       System.Collections.Generic.List`1.Add(T)

Nell'esempio viene definito GetAddMethod un metodo che recupera l' MethodInfo oggetto appropriato.The example defines a GetAddMethod method that retrieves the appropriate MethodInfo object. Per fornire l' types argomento per un tipo generico aperto, viene chiamato il Type.GetGenericArguments metodo.To provide the types argument for an open generic type, it calls the Type.GetGenericArguments method. Per fornire l' types argomento per un tipo generico chiuso, recupera il valore Type.GenericTypeArguments della proprietà.To provide the types argument for a closed generic type, it retrieves the value of the Type.GenericTypeArguments property.

Commenti

La ricerca di name fa distinzione tra maiuscole e minuscole.The search for name is case-sensitive. La ricerca include metodi pubblici statici e di istanza pubblica.The search includes public static and public instance methods.

Nota

Non è possibile omettere i parametri durante la ricerca di costruttori e metodi.You cannot omit parameters when looking up constructors and methods. È possibile omettere solo i parametri quando si richiama.You can only omit parameters when invoking.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Il name parametro non può includere argomenti di tipo.The name parameter cannot include type arguments. Ad esempio, il C# codice GetMethod("MyGenericMethod<int>") Cerca un metodo con il nome di testo "MyGenericMethod<int>", anziché per un metodo denominato MyGenericMethod con un argomento generico di tipo int.For example, the C# code GetMethod("MyGenericMethod<int>") searches for a method with the text name "MyGenericMethod<int>", rather than for a method named MyGenericMethod that has one generic argument of type int. Usare GetMethod("MyGenericMethod") invece con il parametro appropriato types nella matrice.Instead, use GetMethod("MyGenericMethod") with the appropriate parameter in the types array.

Vedi anche

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

public:
 System::Reflection::MethodInfo ^ GetMethod(System::String ^ name, int genericParameterCount, cli::array <Type ^> ^ types);
public System.Reflection.MethodInfo GetMethod (string name, int genericParameterCount, Type[] types);
member this.GetMethod : string * int * Type[] -> System.Reflection.MethodInfo
Public Function GetMethod (name As String, genericParameterCount As Integer, types As Type()) As MethodInfo

Parametri

genericParameterCount
Int32 Int32 Int32 Int32
types
Type[]

Restituisce

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

Cerca il metodo specificato, usando i vincoli di binding specificati.Searches for the specified method, using the specified binding constraints.

public:
 virtual System::Reflection::MethodInfo ^ GetMethod(System::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

Parametri

name
String String String String

Stringa che contiene il nome del metodo da ottenere.The string containing the name of the method to get.

bindingAttr
BindingFlags BindingFlags BindingFlags BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la ricerca.A bitwise combination of the enumeration values that specify how the search is conducted.

-oppure--or- Default per restituire null.Default to return null.

Restituisce

Oggetto che rappresenta il metodo corrispondente ai requisiti specificati, se presente; in caso contrario, null.An object representing the method that matches the specified requirements, if found; otherwise, null.

Implementazioni

Eccezioni

È stato trovato più di un metodo con il nome specificato e corrispondente ai vincoli di associazione specificati.More than one method is found with the specified name and matching the specified binding constraints.

Esempi

Nell'esempio seguente viene ottenuto il metodo che corrisponde ai flag di associazione specificati.The following example gets the method that matches the specified binding flags.

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 Program
{

    // Method to get:
    public void MethodA() { }


    static void Main(string[] args)
    {

        // Get MethodA()
        MethodInfo mInfo = typeof(Program).GetMethod("MethodA",
            BindingFlags.Public | BindingFlags.Instance);
        Console.WriteLine("Found method: {0}", mInfo);

    }
}

Imports System.Reflection

Class Program

    ' Method to get:
    Public Sub MethodA()
    End Sub


    Public Shared Sub Main(ByVal args() As String)

        ' Get MethodA()
        Dim mInfo As MethodInfo = GetType(Program).GetMethod("MethodA", _
        	BindingFlags.Public Or BindingFlags.Instance)
        Console.WriteLine("Found method: {0}", mInfo)

    End Sub
End Class

Commenti

I flag BindingFlags di filtro seguenti possono essere usati per definire i metodi da includere nella ricerca:The following BindingFlags filter flags can be used to define which methods to include in the search:

I flag BindingFlags di modifica seguenti possono essere utilizzati per modificare il funzionamento della ricerca:The following BindingFlags modifier flags can be used to change how the search works:

Per altre informazioni, vedere System.Reflection.BindingFlags.See System.Reflection.BindingFlags for more information.

Se un metodo è sottoposto a overload e più di un overload soddisfa i vincoli specificati dall' bindingAttr argomento, il metodo genera un' AmbiguousMatchException eccezione.If a method is overloaded and more than one overload meets the constraints specified by the bindingAttr argument, the method throws an AmbiguousMatchException exception. Nell'esempio seguente viene generata un'eccezione in quanto:In the following example, an exception is thrown because:

  • Il TestClass tipo dispone DisplayValue di due overload di istanza pubblici del metodo, DisplayValue(String) e DisplayValue(String, Object[]).The TestClass type has two public instance overloads of the DisplayValue method, DisplayValue(String) and DisplayValue(String, Object[]).

  • Il TestClass tipo dispone Equals di due overload di istanza pubblici del metodo, uno dei quali viene ereditato da Object: Equals(TestClass) e Equals(Object).The TestClass type has two public instance overloads of the Equals method, one of which is inherited from Object: Equals(TestClass) and Equals(Object).

using System;
using System.Reflection;

public class TestClass
{
   public void DisplayValue(String s)
   {
      Console.WriteLine(s);
   }
   
   public void DisplayValue(String s, params Object[] values)
   {
      Console.WriteLine(s, values);
   }
   
   public static bool Equals(TestClass t1, TestClass t2)
   {
      return Object.ReferenceEquals(t1, t2);
   }
   
   public bool Equals(TestClass t) 
   {
      return Object.ReferenceEquals(this, t);
   }          
}

public class Example
{
   public static void Main()
   {
      Type t = typeof(TestClass);
      
      RetrieveMethod(t, "DisplayValue", BindingFlags.Public | BindingFlags.Instance);

      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance);
      
      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
      
      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Static);
   }
   
   private static void RetrieveMethod(Type t, String name, BindingFlags flags)
   {
      try {
         MethodInfo m = t.GetMethod(name, flags);
         if (m != null) {
            Console.Write("{0}.{1}(", t.Name, m.Name);
            ParameterInfo[] parms= m.GetParameters();
            for (int ctr = 0; ctr <parms.Length; ctr++) {
               Console.Write(parms[ctr].ParameterType.Name);
               if (ctr < parms.Length - 1) 
                  Console.Write(", ");

            }
            Console.WriteLine(")");
         }
         else {
            Console.WriteLine("Method not found");
         }
      }
      catch (AmbiguousMatchException) {
         Console.WriteLine("The following duplicate matches were found:");
         MethodInfo[] methods = t.GetMethods(flags);
         foreach (var method in methods) {
            if (method.Name != name) continue;

            Console.Write("   {0}.{1}(", t.Name, method.Name);
            ParameterInfo[] parms = method.GetParameters();
            for (int ctr = 0; ctr < parms.Length; ctr++) {
               Console.Write(parms[ctr].ParameterType.Name);
               if (ctr < parms.Length - 1) 
                  Console.Write(", ");

            }
            Console.WriteLine(")");
         } 
      }         
      Console.WriteLine();
   }
}
// The example displays the following output:
//       The following duplicate matches were found:
//          TestClass.DisplayValue(String)
//          TestClass.DisplayValue(String, Object[])
//       
//       The following duplicate matches were found:
//          TestClass.Equals(TestClass)
//          TestClass.Equals(Object)
//       
//       TestClass.Equals(TestClass)
//       
//       TestClass.Equals(TestClass, TestClass)
Imports System.Reflection

Public Class TestClass
   Public Sub DisplayValue(s As String)
      Console.WriteLine(s)
   End Sub
   
   Public Sub DisplayValue(s As String, ParamArray values() As Object)
      Console.WriteLine(s, values)
   End Sub
   
   Public Overloads Shared Function Equals(t1 As TestClass, t2 As TestClass) As Boolean
      Return Object.ReferenceEquals(t1, t2)
   End Function
   
   Public Overloads Function Equals(t As TestClass) As Boolean
      Return Object.ReferenceEquals(Me, t)
   End Function          
End Class

Module Example
   Public Sub Main()
      Dim t As Type = GetType(TestClass)
      
      RetrieveMethod(t, "DisplayValue", BindingFlags.Public Or BindingFlags.Instance)

      RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Instance)
      
      RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.DeclaredOnly)
      
      RetrieveMethod(t, "Equals", BindingFlags.Public Or BindingFlags.Static)
   End Sub
   
   Public Sub RetrieveMethod(t As Type, name As String, flags As BindingFlags)
      Try
         Dim m As MethodInfo = t.GetMethod(name, flags)
         If m IsNot Nothing Then
            Console.Write("{0}.{1}(", t.Name, m.Name)
           Dim parms() As ParameterInfo = m.GetParameters()
            For ctr As Integer = 0 To parms.Length - 1
               Console.Write(parms(ctr).ParameterType.Name)
               if ctr < parms.Length - 1 Then 
                  Console.Write(", ")
               End If      
            Next
            Console.WriteLine(")")
         Else
            Console.WriteLine("Method not found")
         End If
      Catch e As AmbiguousMatchException
         Console.WriteLine("The following duplicate matches were found:")
         Dim methods() As MethodInfo = t.GetMethods(flags)
         For Each method In methods
            If method.Name <> name Then Continue For

            Console.Write("   {0}.{1}(", t.Name, method.Name)
            Dim parms() As ParameterInfo = method.GetParameters()
            For ctr As Integer = 0 To parms.Length - 1
               Console.Write(parms(ctr).ParameterType.Name)
               if ctr < parms.Length - 1 Then 
                  Console.Write(", ")
               End If      
            Next
            Console.WriteLine(")")
         Next 
      End Try         
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       The following duplicate matches were found:
'          TestClass.DisplayValue(String)
'          TestClass.DisplayValue(String, Object[])
'       
'       The following duplicate matches were found:
'          TestClass.Equals(TestClass)
'          TestClass.Equals(Object)
'       
'       TestClass.Equals(TestClass)
'       
'       TestClass.Equals(TestClass, TestClass)

Per recuperare un metodo specifico, è possibile eseguire una delle operazioni seguenti:You can do one of the following to retrieve a specific method:

  • Modificare i vincoli di binding.Change the binding constraints. Nell'esempio precedente, il tentativo di recuperare un metodo di istanza Equals pubblica dichiarata dal tipo e non ereditato viene recuperato Equals(TestClass)correttamente.In the previous example, attempting to retrieve a public instance Equals method that is declared by the type and not inherited successfully retrieves Equals(TestClass).

  • Chiamare un overload del GetMethod metodo che include un types parametro che definisce i tipi dei parametri del metodo.Call an overload of the GetMethod method that includes a types parameter which defines the types of the method's parameters.

  • Chiamare il GetMethods(BindingFlags) metodo per recuperare una matrice contenente tutti i metodi appartenenti a un tipo con gli attributi di associazione specificati.Call the GetMethods(BindingFlags) method to retrieve an array containing all of the methods belonging to a type that have the specified binding attributes. È quindi possibile eseguire l'iterazione per identificare i metodi nameduplicati denominati.You can then iterate it to identify the duplicate methods named name. Questo approccio è illustrato nel gestore dell'esempio precedente per l' AmbiguousMatchException eccezione.This approach is illustrated in the previous example's handler for the AmbiguousMatchException exception.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Per i metodi generici, non includere gli argomenti di nametipo in.For generic methods, do not include the type arguments in name. Ad esempio, il C# codice GetMember("MyMethod<int>") Cerca un membro con il nome di testo "MyMethod<int>", anziché per un metodo denominato MyMethod con un argomento generico di tipo int.For example, the C# code GetMember("MyMethod<int>") searches for a member with the text name "MyMethod<int>", rather than for a method named MyMethod that has one generic argument of type int.

Vedi anche

GetMethod(String) GetMethod(String) GetMethod(String) GetMethod(String)

Cerca il metodo pubblico con il nome specificato.Searches for the public method with the specified name.

public:
 virtual System::Reflection::MethodInfo ^ GetMethod(System::String ^ name);
public System.Reflection.MethodInfo GetMethod (string name);
abstract member GetMethod : string -> System.Reflection.MethodInfo
override this.GetMethod : string -> System.Reflection.MethodInfo
Public Function GetMethod (name As String) As MethodInfo

Parametri

name
String String String String

Stringa che contiene il nome del metodo pubblico da ottenere.The string containing the name of the public method to get.

Restituisce

Oggetto che rappresenta il metodo pubblico con il nome specificato, se è stato trovato; in caso contrario, null.An object that represents the public method with the specified name, if found; otherwise, null.

Implementazioni

Eccezioni

È stato trovato più di un metodo con il nome specificato.More than one method is found with the specified name.

Esempi

Nell'esempio seguente viene ottenuto un metodo MethodAdenominato.The following example gets a method named MethodA.

using namespace System;
using namespace System::Reflection;
public ref class Program
{

    public:

        // Method to get:
        void MethodA() { }

    };

    int main()
    {

        // Get MethodA()
        MethodInfo^ mInfo = Program::typeid->GetMethod("MethodA");
        Console::WriteLine("Found method: {0}", mInfo );

    }

using System;
using System.Reflection;

class Program
{

    // Method to get:
    public void MethodA() { }


    static void Main(string[] args)
    {

        // Get MethodA()
        MethodInfo mInfo = typeof(Program).GetMethod("MethodA");
        Console.WriteLine("Found method: {0}", mInfo);

    }
}

Imports System.Reflection

Class Program

    ' Method to get:
    Public Sub MethodA()
    End Sub


    Public Shared Sub Main(ByVal args() As String)

        ' Get MethodA()
        Dim mInfo As MethodInfo = GetType(Program).GetMethod("MethodA")
        Console.WriteLine("Found method: {0}", mInfo)

    End Sub
End Class

Commenti

La ricerca di name fa distinzione tra maiuscole e minuscole.The search for name is case-sensitive. La ricerca include metodi pubblici statici e di istanza pubblica.The search includes public static and public instance methods.

Se un metodo è sottoposto a overload ed è dotato di più di un metodo GetMethod(String) pubblico, il AmbiguousMatchException metodo genera un'eccezione.If a method is overloaded and has more than one public method, the GetMethod(String) method throws an AmbiguousMatchException exception. Nell'esempio seguente viene generata un'eccezione perché esiste più di un overload pubblico del Int32.ToString metodo.In the following example, an exception is thrown because there is more than one public overload of the Int32.ToString method. D'altra parte, poiché Person.ToString il metodo esegue l'override Object.ToString di e pertanto non è in overload, GetMethod(String) il metodo è in grado di MethodInfo recuperare l'oggetto.On the other hand, because the Person.ToString method overrides Object.ToString and therefore is not overloaded, the GetMethod(String) method is able to retrieve the MethodInfo object.

using System;
using System.Reflection;

public class Person
{
   public String FirstName;
   public String LastName;
   
   public override String ToString()
   {
      return (FirstName + " " + LastName).Trim();
   }
}

public class Example
{
   public static void Main()
   {
      Type t = typeof(Person);
      RetrieveMethod(t, "ToString");
      
      t = typeof(Int32);
      RetrieveMethod(t, "ToString");
   }

   private static void RetrieveMethod(Type t, String name)
   {   
      try {
         MethodInfo m = t.GetMethod(name);
         if (m != null) 
            Console.WriteLine("{0}.{1}: {2} method", m.ReflectedType.Name,
                              m.Name, m.IsStatic ? "Static" : "Instance");    
         else
            Console.WriteLine("{0}.ToString method not found", t.Name);
      }
      catch (AmbiguousMatchException) {
         Console.WriteLine("{0}.{1} has multiple public overloads.", 
                           t.Name, name);
      }
   }
}
// The example displays the following output:
//       Person.ToString: Instance method
//       Int32.ToString has multiple public overloads.
Imports System.Reflection

Public Class Person
   Public FirstName As String
   Public LastName As String
   
   Public Overrides Function ToString() As String
      Return (FirstName + " " + LastName).Trim()
   End Function
End Class

Module Example
   Public Sub Main()
      Dim t As Type = GetType(Person)
      RetrieveMethod(t, "ToString")
      
      t = GetType(Int32)
      RetrieveMethod(t, "ToString")
   End Sub
   
   Private Sub RetrieveMethod(t As Type, name As String)   
      Try
         Dim m As MethodInfo = t.GetMethod(name)
         If m IsNot Nothing Then
            Console.WriteLine("{0}.{1}: {2} method", m.ReflectedType.Name,
                              m.Name, If(m.IsStatic, "Static", "Instance"))    
         Else
            Console.WriteLine("{0}.ToString method not found", t.Name)
         End If   
      Catch e As AmbiguousMatchException
         Console.WriteLine("{0}.{1} has multiple public overloads.", 
                           t.Name, name)
      End Try
   End Sub
End Module
' The example displays the following output:
'       Person.ToString: Instance method
'       Int32.ToString has multiple public overloads.

Per recuperare un metodo specifico, è possibile eseguire una delle operazioni seguenti:You can do one of the following to retrieve a specific method:

  • Chiamare il GetMethod(String, BindingFlags) metodo e specificare un bindingAttr argomento che identifichi in modo univoco il metodo.Call the GetMethod(String, BindingFlags) method and specify a bindingAttr argument that uniquely identifies the method. Se, ad esempio, l'eccezione viene generata perché un tipo dispone di un overload statico e di un'istanza, è bindingAttr possibile specificare BindingFlags.Instanceun argomento di Or. BindingFlags.InstanceFor example, if the exception is thrown because a type has a static and an instance overload, you can specify a bindingAttr argument of BindingFlags.InstanceOrBindingFlags.Instance.

  • Chiamare un overload del GetMethod metodo che include un types parametro che definisce i tipi dei parametri del metodo.Call an overload of the GetMethod method that includes a types parameter which defines the types of the method's parameters.

  • Chiamare il GetMethods() metodo per recuperare una matrice contenente tutti i metodi pubblici appartenenti a un tipo.Call the GetMethods() method to retrieve an array containing all of the public methods belonging to a type. È quindi possibile eseguire l'iterazione per identificare i metodi nameduplicati denominati.You can then iterate it to identify the duplicate methods named name.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Per i metodi generici, non includere gli argomenti di nametipo in.For generic methods, do not include the type arguments in name. Ad esempio, il C# codice GetMember("MyMethod<int>") Cerca un membro con il nome di testo "MyMethod<int>", anziché per un metodo denominato MyMethod con un argomento generico di tipo int.For example, the C# code GetMember("MyMethod<int>") searches for a member with the text name "MyMethod<int>", rather than for a method named MyMethod that has one generic argument of type int.

Vedi anche

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

Cerca il metodo pubblico specificato i cui parametri corrispondono ai modificatori e ai tipi di argomenti specificati.Searches for the specified public method whose parameters match the specified argument types and 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);
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

Parametri

name
String String String String

Stringa che contiene il nome del metodo pubblico da ottenere.The string containing the name of the public method to get.

types
Type[]

Matrice di oggetti Type che rappresentano numero, ordine e tipo dei parametri relativi al metodo da ottenere.An array of Type objects representing the number, order, and type of the parameters for the method to get.

In alternativa-or- Matrice vuota di oggetti Type (come fornita dal campo EmptyTypes) per ottenere un metodo che non accetta parametri.An empty array of Type objects (as provided by the EmptyTypes field) to get a method that takes no parameters.

modifiers
ParameterModifier[]

Matrice di oggetti ParameterModifier che rappresentano gli attributi associati all'elemento corrispondente nella matrice types.An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. Da usare solo quando si effettuano chiamate tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.To be only used when calling through COM interop, and only parameters that are passed by reference are handled. Questo parametro non viene elaborato dal binder predefinito.The default binder does not process this parameter.

Restituisce

Oggetto che rappresenta il metodo pubblico corrispondente ai requisiti specificati, se è stato trovato; in caso contrario, null.An object representing the public method that matches the specified requirements, if found; otherwise, null.

Implementazioni

Eccezioni

Sono stati trovati più metodi con il nome e i parametri specificati.More than one method is found with the specified name and specified parameters.

name è null.name is null.

In alternativa-or- types è null.types is null.

-oppure--or- Uno degli elementi in types è null.One of the elements in types is null.

types è multidimensionale.types is multidimensional.

In alternativa-or- modifiers è multidimensionale.modifiers is multidimensional.

Commenti

Sebbene il Binder ParameterModifier predefinito non elabori (il modifiers parametro), è possibile usare la classe astratta System.Reflection.Binder per scrivere un gestore di associazione personalizzato che esegue modifiersl'elaborazione.Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract System.Reflection.Binder class to write a custom binder that does process modifiers. ParameterModifierviene utilizzato solo quando si effettua una chiamata tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

La ricerca di name fa distinzione tra maiuscole e minuscole.The search for name is case-sensitive. La ricerca include metodi pubblici statici e di istanza pubblica.The search includes public static and public instance methods.

Nota

Non è possibile omettere i parametri durante la ricerca di costruttori e metodi.You cannot omit parameters when looking up constructors and methods. È possibile omettere solo i parametri quando si richiama.You can only omit parameters when invoking.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, questo metodo restituisce MethodInfo l'oggetto con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.If the current Type represents a constructed generic type, this method returns the MethodInfo with the type parameters replaced by the appropriate type arguments.

Se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, questo metodo esegue la ricerca nei metodi del vincolo di classe o Object nei metodi di se non è presente alcun vincolo di classe.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the methods of the class constraint, or the methods of Object if there is no class constraint.

Nota

Per i metodi generici, non includere gli argomenti di nametipo in.For generic methods, do not include the type arguments in name. Ad esempio, il C# codice GetMethod("MyMethod<int>") Cerca un membro con il nome di testo "MyMethod<int>", anziché per un metodo denominato MyMethod con un argomento generico di tipo int.For example, the C# code GetMethod("MyMethod<int>") searches for a member with the text name "MyMethod<int>", rather than for a method named MyMethod that has one generic argument of type int. Usare GetMethod("MyMethod") invece con il parametro appropriato types nella matrice.Instead, use GetMethod("MyMethod") with the appropriate parameter in the types array.

Vedi anche

Si applica a