Type.GetMethods Método

Definição

Obtém os métodos do Type atual.Gets the methods of the current Type.

Sobrecargas

GetMethods(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa os métodos definidos para o Type atual usando as restrições de associação especificadas.When overridden in a derived class, searches for the methods defined for the current Type, using the specified binding constraints.

GetMethods()

Retorna todos os métodos públicos do Type atual.Returns all the public methods of the current Type.

GetMethods(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa os métodos definidos para o Type atual usando as restrições de associação especificadas.When overridden in a derived class, searches for the methods defined for the current Type, using the specified binding constraints.

public:
 abstract cli::array <System::Reflection::MethodInfo ^> ^ GetMethods(System::Reflection::BindingFlags bindingAttr);
public abstract System.Reflection.MethodInfo[] GetMethods (System.Reflection.BindingFlags bindingAttr);
abstract member GetMethods : System.Reflection.BindingFlags -> System.Reflection.MethodInfo[]
Public MustOverride Function GetMethods (bindingAttr As BindingFlags) As MethodInfo()

Parâmetros

bindingAttr
BindingFlags

Uma combinação bit a bit dos valores de enumeração que especificam como a pesquisa é realizada.A bitwise combination of the enumeration values that specify how the search is conducted.

- ou --or-

Default para retornar uma matriz vazia.Default to return an empty array.

Retornos

Uma matriz de objetos MethodInfo representando todos os métodos definidos para o Type atual que correspondem às restrições de associação especificadas.An array of MethodInfo objects representing all methods defined for the current Type that match the specified binding constraints.

- ou --or- Uma matriz vazia do tipo MethodInfo, se nenhum método estiver definido para o atual Type, ou se nenhum dos métodos definidos corresponder às restrições de associação.An empty array of type MethodInfo, if no methods are defined for the current Type, or if none of the defined methods match the binding constraints.

Implementações

Exemplos

O exemplo a seguir cria uma classe com dois métodos públicos e um método protegido, cria Type um objeto correspondente MyTypeClassa, obtém todos os métodos públicos e não públicos e exibe seus nomes.The following example creates a class with two public methods and one protected method, creates a Type object corresponding to MyTypeClass, gets all public and non-public methods, and displays their names.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

// Create a class having two public methods and one protected method.
public ref class MyTypeClass
{
public:
   void MyMethods(){}

   int MyMethods1()
   {
      return 3;
   }


protected:
   String^ MyMethods2()
   {
      return "hello";
   }
};

void DisplayMethodInfo( array<MethodInfo^>^myArrayMethodInfo )
{
   // Display information for all methods.
   for ( int i = 0; i < myArrayMethodInfo->Length; i++ )
   {
      MethodInfo^ myMethodInfo = dynamic_cast<MethodInfo^>(myArrayMethodInfo[ i ]);
      Console::WriteLine( "\nThe name of the method is {0}.", myMethodInfo->Name );
   }
}

int main()
{
   Type^ myType = MyTypeClass::typeid;
   
   // Get the public methods.
   array<MethodInfo^>^myArrayMethodInfo = myType->GetMethods( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance | BindingFlags::DeclaredOnly) );
   Console::WriteLine( "\nThe number of public methods is {0}->", myArrayMethodInfo->Length );
   
   // Display all the methods.
   DisplayMethodInfo( myArrayMethodInfo );
   
   // Get the nonpublic methods.
   array<MethodInfo^>^myArrayMethodInfo1 = myType->GetMethods( static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::DeclaredOnly) );
   Console::WriteLine( "\nThe number of protected methods is {0}->", myArrayMethodInfo1->Length );
   
   // Display information for all methods.
   DisplayMethodInfo( myArrayMethodInfo1 );
}

using System;
using System.Reflection;
using System.Reflection.Emit;

        // Create a class having two public methods and one protected method.
public class MyTypeClass
{
    public void MyMethods()
    {
    }
    public int MyMethods1() 
    {
        return 3;
    }
    protected String MyMethods2()
    {
        return "hello";
    }
}
public class TypeMain
{
    public static void Main() 
    {
        Type myType =(typeof(MyTypeClass));
        // Get the public methods.
        MethodInfo[] myArrayMethodInfo = myType.GetMethods(BindingFlags.Public|BindingFlags.Instance|BindingFlags.DeclaredOnly);
        Console.WriteLine("\nThe number of public methods is {0}.", myArrayMethodInfo.Length);
        // Display all the methods.
        DisplayMethodInfo(myArrayMethodInfo);
        // Get the nonpublic methods.
        MethodInfo[] myArrayMethodInfo1 = myType.GetMethods(BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.DeclaredOnly);
        Console.WriteLine("\nThe number of protected methods is {0}.", myArrayMethodInfo1.Length);
        // Display information for all methods.
        DisplayMethodInfo(myArrayMethodInfo1);		
    }
    public static void DisplayMethodInfo(MethodInfo[] myArrayMethodInfo)
    {
        // Display information for all methods.
        for(int i=0;i<myArrayMethodInfo.Length;i++)
        {
            MethodInfo myMethodInfo = (MethodInfo)myArrayMethodInfo[i];
            Console.WriteLine("\nThe name of the method is {0}.", myMethodInfo.Name);
        }
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

' Create a class having two public methods and one protected method.
Public Class MyTypeClass
    Public Sub MyMethods()
    End Sub
    Public Function MyMethods1() As Integer
        Return 3
    End Function 'MyMethods1
    Protected Function MyMethods2() As [String]
        Return "hello"
    End Function 'MyMethods2
End Class
Public Class TypeMain
    Public Shared Sub Main()

        Dim myType As Type = GetType(MyTypeClass)
        ' Get the public methods.
        Dim myArrayMethodInfo As MethodInfo() = myType.GetMethods((BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.DeclaredOnly))
        Console.WriteLine((ControlChars.Cr + "The number of public methods is " & myArrayMethodInfo.Length.ToString() & "."))
        ' Display all the public methods.
        DisplayMethodInfo(myArrayMethodInfo)
        ' Get the nonpublic methods.
        Dim myArrayMethodInfo1 As MethodInfo() = myType.GetMethods((BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.DeclaredOnly))
        Console.WriteLine((ControlChars.Cr + "The number of protected methods is " & myArrayMethodInfo1.Length.ToString() & "."))
        ' Display all the nonpublic methods.
        DisplayMethodInfo(myArrayMethodInfo1)
    End Sub

    Public Shared Sub DisplayMethodInfo(ByVal myArrayMethodInfo() As MethodInfo)
        ' Display information for all methods.
        Dim i As Integer
        For i = 0 To myArrayMethodInfo.Length - 1
            Dim myMethodInfo As MethodInfo = CType(myArrayMethodInfo(i), MethodInfo)
            Console.WriteLine((ControlChars.Cr + "The name of the method is " & myMethodInfo.Name & "."))
        Next i
    End Sub
End Class

Comentários

Para que GetMethods(BindingFlags) a sobrecarga recupere as informações do método com êxito bindingAttr , o argumento deve incluir pelo menos BindingFlags.Instance um BindingFlags.Staticde e, juntamente com pelo menos BindingFlags.NonPublic um BindingFlags.Publicde e.For the GetMethods(BindingFlags) overload to successfully retrieve method information, the bindingAttr argument must include at least one of BindingFlags.Instance and BindingFlags.Static, along with at least one of BindingFlags.NonPublic and BindingFlags.Public.

Os seguintes sinalizadores de filtro BindingFlags podem ser usados para definir quais métodos devem ser incluídos na pesquisa:The following BindingFlags filter flags can be used to define which methods to include in the search:

  • Especifique BindingFlags.Instance para incluir os métodos de instância.Specify BindingFlags.Instance to include instance methods.

  • Especifique BindingFlags.Static para incluir métodos estáticos.Specify BindingFlags.Static to include static methods.

  • Especifique BindingFlags.Public para incluir métodos públicos na pesquisa.Specify BindingFlags.Public to include public methods in the search.

  • Especifique BindingFlags.NonPublic para incluir métodos não públicos (ou seja, métodos privados, internos e protegidos) na pesquisa.Specify BindingFlags.NonPublic to include non-public methods (that is, private, internal, and protected methods) in the search. Somente métodos protegidos e internos em classes base são retornados; métodos privados em classes base não são retornados.Only protected and internal methods on base classes are returned; private methods on base classes are not returned.

  • Especifique BindingFlags.FlattenHierarchy para incluir os membros estáticos public e protected acima na hierarquia; os membros estáticos private em classes herdadas não são incluídos.Specify BindingFlags.FlattenHierarchy to include public and protected static members up the hierarchy; private static members in inherited classes are not included.

  • Especifique BindingFlags.Default sozinho para retornar uma matriz MethodInfo vazia.Specify BindingFlags.Default alone to return an empty MethodInfo array.

Os seguintes sinalizadores de modificador BindingFlags podem ser usados para alterar como a pesquisa funciona:The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.DeclaredOnly para procurar apenas os métodos declarados no Type, e não os métodos que foram simplesmente herdados.BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

Consulte System.Reflection.BindingFlags para obter mais informações.See System.Reflection.BindingFlags for more information.

O GetMethods método não retorna métodos em uma ordem específica, como ordem alfabética ou declaração.The GetMethods method does not return methods in a particular order, such as alphabetical or declaration order. Seu código não deve depender da ordem em que os métodos são retornados, pois essa ordem varia.Your code must not depend on the order in which methods are returned, because that order varies.

Se o atual Type representar um tipo genérico construído, esse método retornará os MethodInfo objetos com os parâmetros de tipo substituídos pelos argumentos de tipo apropriados.If the current Type represents a constructed generic type, this method returns the MethodInfo objects with the type parameters replaced by the appropriate type arguments.

Caso o Type atual represente um parâmetro de tipo na definição de um tipo genérico ou um método genérico, este método pesquisa os métodos de restrição da classe ou os métodos de Object caso não haja restrição de 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.

Veja também

GetMethods()

Retorna todos os métodos públicos do Type atual.Returns all the public methods of the current Type.

public:
 virtual cli::array <System::Reflection::MethodInfo ^> ^ GetMethods();
public System.Reflection.MethodInfo[] GetMethods ();
abstract member GetMethods : unit -> System.Reflection.MethodInfo[]
override this.GetMethods : unit -> System.Reflection.MethodInfo[]
Public Function GetMethods () As MethodInfo()

Retornos

Uma matriz de objetos MethodInfo que representam todos os métodos públicos definidos para o Type atual.An array of MethodInfo objects representing all the public methods defined for the current Type.

- ou --or- Uma matriz vazia do tipo MethodInfo, se nenhum método público for definido para o Type atual.An empty array of type MethodInfo, if no public methods are defined for the current Type.

Implementações

Comentários

O GetMethods método não retorna métodos em uma ordem específica, como ordem alfabética ou declaração.The GetMethods method does not return methods in a particular order, such as alphabetical or declaration order. Seu código não deve depender da ordem em que os métodos são retornados, pois essa ordem varia.Your code must not depend on the order in which methods are returned, because that order varies.

Os construtores não são incluídos na matriz de métodos retornados por essa chamada.Constructors are not included in the array of methods returned by this call. Faça uma chamada separada para GetConstructors() para obter os métodos do construtor.Make a separate call to GetConstructors() to get the constructor methods.

A tabela a seguir mostra quais membros de uma classe base são retornados pelos métodos Get durante a reflexão em um tipo.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo do membroMember Type EstáticoStatic Não estáticoNon-Static
ConstrutorConstructor NãoNo NãoNo
CampoField NãoNo Sim.Yes. Um campo permanece sempre oculto por nome e assinatura.A field is always hide-by-name-and-signature.
eventoEvent Não aplicávelNot applicable A regra de sistema do tipo comum é que a herança é a mesma dos métodos que implementam a propriedade.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflexão trata propriedades como ocultas por nome e assinatura.Reflection treats properties as hide-by-name-and-signature. Consulte a observação 2 abaixo.See note 2 below.
MétodoMethod NãoNo Sim.Yes. Um método (virtual e não virtual) pode permanecer oculto por nome ou por nome e assinatura.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo aninhadoNested Type NãoNo NãoNo
PropriedadeProperty Não aplicávelNot applicable A regra de sistema do tipo comum é que a herança é a mesma dos métodos que implementam a propriedade.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflexão trata propriedades como ocultas por nome e assinatura.Reflection treats properties as hide-by-name-and-signature. Consulte a observação 2 abaixo.See note 2 below.
  1. Oculto por nome e assinatura considera todas as partes da assinatura, inclusive modificadores personalizados, tipos de retorno, tipos de parâmetro, sentinelas e convenções de chamada não gerenciadas.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. Esta é uma comparação binária.This is a binary comparison.

  2. Para reflexão, propriedades e eventos permanecem ocultos por nome e assinatura.For reflection, properties and events are hide-by-name-and-signature. Se você tiver uma propriedade com um acessador get e set na classe base, mas a classe derivada tiver apenas um acessador get, a propriedade de classe derivada ocultará a propriedade da classe base e você não poderá acessar o setter na classe 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. Atributos personalizados não fazem parte do sistema de tipo comum.Custom attributes are not part of the common type system.

Observação

Não é possível omitir parâmetros durante a pesquisa de construtores e métodos.You cannot omit parameters when looking up constructors and methods. Só é possível omitir parâmetros durante a invocação.You can only omit parameters when invoking.

Se o atual Type representar um tipo genérico construído, esse método retornará os MethodInfo objetos com os parâmetros de tipo substituídos pelos argumentos de tipo apropriados.If the current Type represents a constructed generic type, this method returns the MethodInfo objects with the type parameters replaced by the appropriate type arguments.

Caso o Type atual represente um parâmetro de tipo na definição de um tipo genérico ou um método genérico, este método pesquisa os métodos de restrição da classe ou os métodos de Object caso não haja restrição de 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.

Veja também

Aplica-se a