Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Método Type.GetMethod (String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Procura o método especificado cujos parâmetros correspondem aos tipos de argumento especificado e modificadores, usando as restrições de vinculação especificada e a convenção de chamada especificada.

Namespace:  System
Assembly:  mscorlib (em mscorlib.dll)

public MethodInfo GetMethod(
	string name,
	BindingFlags bindingAttr,
	Binder binder,
	CallingConventions callConvention,
	Type[] types,
	ParameterModifier[] modifiers
)

Parâmetros

name
Tipo: System.String
The String que contém o nome do método obter.
bindingAttr
Tipo: System.Reflection.BindingFlags
Uma máscara de bits composta de um ou mais BindingFlags que especificam como a Pesquisar é realizada.
- ou -
Zero, para retornar null.
binder
Tipo: System.Reflection.Binder
A Binder objeto que define um conjunto de propriedades e permite a ligação, que pode envolver a seleção de um método sobrecarregado coerção de tipos de argumento e invocação de um membro por meio de reflexão.
- ou -
null , para usar o DefaultBinder.
callConvention
Tipo: System.Reflection.CallingConventions
The CallingConventions objeto que especifica o conjunto de regras para usar em relação à ordem e o layout dos argumentos, como o valor retornado é passado, quais registros são usados para argumentos e como a pilha é limpa.
types
Tipo: System.Type[]
Uma matriz de Type objetos que representam o número, ordem e tipo de parâmetros para o método obter.
- ou -
Uma matriz vazia de Type objetos (conforme fornecido pela EmptyTypes campo) para obter um método que não usa nenhum parâmetro.
modifiers
Tipo: System.Reflection.ParameterModifier[]
Uma matriz de ParameterModifier objetos que representam os atributos associados o elemento correspondente no types matriz. A ser usada somente quando chamando por meio de parâmetros de interoperabilidade e somente COM que são passados referência são manipuladas.O fichário padrão não processa este parâmetro.

Valor de retorno

Tipo: System.Reflection.MethodInfo
A MethodInfo objeto que representa o método que combina os requisitos especificados, se encontrados; caso contrário, null.

Implementações

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

ExceçãoCondição
AmbiguousMatchException

Mais de um método com o nome especificado é localizado e correspondência as restrições de vinculação especificada.

ArgumentNullException

name é null.

- ou -

types é null.

- ou -

Um dos elementos em types é null.

ArgumentException

types é multidimensional.

- ou -

modifiers é multidimensional.

Embora o fichário padrão não processa ParameterModifier (o modifiers parâmetro), você pode usar o resumo System.Reflection.Binder classe de um fichário personalizado que processo de gravar modifiers. ParameterModifier só é usado ao chamar através de interoperabilidade COM, e somente os parâmetros são passados por referência são manipulados.

A tabela a seguir mostra quais membros de uma classe base são retornados pelo GetXXX métodos quando refletindo em um tipo.

Tipo de membro

Estático

Não-estático

Construtor

Não

Não

Campo

Não

Sim. Um campo é sempre ocultar-por-nome-e-assinatura.

Evento

Não aplicável.

A regra de sistema de tipo comum é que a herança é o mesmo que sistema autônomo métodos que implementam a propriedade.Reflexão trata propriedades sistema autônomo ocultar-por-nome-e-assinatura.Consulte Observação 2 abaixo.

Método

Não

Sim. Um método (virtual e não-virtual) pode ser oculta por nome ou ocultar-por-nome-e-assinatura.

Tipo aninhado

Não

Não

Propriedade

Não aplicável.

A regra de sistema de tipo comum é que a herança é o mesmo que sistema autônomo métodos que implementam a propriedade.Reflexão trata propriedades sistema autônomo ocultar-por-nome-e-assinatura.Consulte Observação 2 abaixo.

  1. Ocultar-por-nome-e-assinatura considera todas as partes da assinatura, incluindo modificadores personalizados, retornam tipos, tipos de parâmetro, sentinels e convenções de chamada não gerenciadas.Isso é uma comparação binária.

  2. Para reflexão, propriedades e eventos são ocultar-por-nome-e-assinatura.Se você tem uma propriedade com um get e um acessador conjunto na classe base, mas a classe derivada tem apenas um acessador get, a propriedade de classe derivada oculta a propriedade de classe base e não poderão acessar o setter na classe base.

  3. Atributos personalizados não fazem parte do common type sistema.

A seguir BindingFlags sinalizadores de filtro podem ser usados para definir quais métodos para incluir na Pesquisar:

  • Você deve especificar um dos BindingFlags.Instance ou BindingFlags.Static Para obter um retorno.

  • Especificar BindingFlags.Public para incluir métodos públicos na Pesquisar.

  • Especificar BindingFlags.NonPublic para incluir métodos confidenciais (ou seja, membros protegidos e particulares) na Pesquisar.

  • Especificar BindingFlags.FlattenHierarchy para incluir public e protected membros estático da hierarquia; private membros estático em classes herdadas não são incluídos.

A seguir BindingFlags sinalizadores de modificador podem ser usadas para alterar o modo como funciona a Pesquisar:

  • BindingFlags.IgnoreCase para ignorar o caso de name.

  • BindingFlags.DeclaredOnly Para pesquisar apenas os métodos declarados na Type, não os métodos que simplesmente foram herdados.

Consulte System.Reflection.BindingFlags para obter mais informações.

Se o método solicitado é confidenciais e o chamador não tem ReflectionPermission para refletir objetos confidenciais fora do assembly corrente, esse método retorna null.

ObservaçãoObservação:

Você não pode omitir parâmetros ao procurar métodos e construtores.Você pode omitir somente parâmetros ao chamar.

Se T:sistema.Type corrente representa um tipo genérico construído, este método retornará o MethodInfo com os parâmetros de tipo substituídos pelos argumentos de tipo apropriado.

Se o corrente Type representa um parâmetro de tipo na definição de um tipo genérico ou método genérico, esse método procura os métodos de restrição de classe ou os métodos do Object Se não houver nenhuma restrição de classe.

ObservaçãoObservação:

Para métodos genéricos, não inclua os argumentos de tipo em name.Por exemplo, o translation from VPE for Csharp código GetMember("MyMethod<int>")procura por um membro com o nome de texto"MyMethod<int>", em vez de um método chamado MyMethod que tem um argumento genérico do tipo int.

O exemplo a seguir localiza específicas sobrecargas de MethodA, especificando restrições de ligação, chamando as convenções e uma variedade de tipos de argumento.

ObservaçãoObservação:

O Visual C# 2005 exemplo requer o /unsafeopção do compilador .

using System;
using System.Reflection;

class Program
{
    // Methods to get:publicvoid MethodA(int i, int j) { }

    publicvoid MethodA(int[] i) { }

    public unsafe void MethodA(int* i) { }

    publicvoid MethodA(refint r) {}

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


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

  }
}



import System.*;
import System.Reflection.*;

public class Program
{
	// Methods to get:

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

	public void MethodA(int[] i) { }

    public static void main(String[] args)
    {
		MethodInfo mInfo;
		Type tProgram = Program.class.ToType();


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

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

    }
}



Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatível com: 3.5, 2.0, 1.0

XNA Framework

Compatível com: , 1.0

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2015 Microsoft