MethodBase.Invoke Método
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Invoca o método ou construtor refletido por esta MethodInfo instância.
Sobrecargas
| Name | Description |
|---|---|
| Invoke(Object, Object[]) |
Invoca o método ou construtor representado pela instância atual, usando os parâmetros especificados. |
| Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Quando sobrescrito numa classe derivada, invoca o método ou construtor refletido com os parâmetros dados. |
Invoke(Object, Object[])
Invoca o método ou construtor representado pela instância atual, usando os parâmetros especificados.
public:
virtual System::Object ^ Invoke(System::Object ^ obj, cli::array <System::Object ^> ^ parameters);public:
System::Object ^ Invoke(System::Object ^ obj, cli::array <System::Object ^> ^ parameters);public virtual object Invoke(object obj, object[] parameters);public object Invoke(object obj, object[] parameters);abstract member Invoke : obj * obj[] -> obj
override this.Invoke : obj * obj[] -> objmember this.Invoke : obj * obj[] -> objPublic Overridable Function Invoke (obj As Object, parameters As Object()) As ObjectPublic Function Invoke (obj As Object, parameters As Object()) As ObjectParâmetros
- obj
- Object
O objeto sobre o qual invocar o método ou construtor. Se um método for estático, este argumento é ignorado. Se um construtor for estático, este argumento deve ser null ou uma instância da classe que define o construtor.
- parameters
- Object[]
Uma lista de argumentos para o método ou construtor invocado. Trata-se de um array de objetos com o mesmo número, ordem e tipo que os parâmetros do método ou construtor a invocar. Se não houver parâmetros, parameters deve ser null.
Se o método ou construtor representado por esta instância tomar um parâmetro ref (ByRef em Visual Basic), não é necessário nenhum atributo especial para esse parâmetro para invocar o método ou construtor usando esta função. Qualquer objeto neste array que não esteja explicitamente inicializado com um valor conterá o valor padrão para esse tipo de objeto. Para elementos do tipo de referência, este valor é null. Para elementos de tipo valor, o valor padrão é 0, 0,0 ou false, dependendo do tipo específico de elemento.
Devoluções
Um objeto contendo o valor de retorno do método invocado, ou null no caso de um construtor.
Implementações
Exceções
O obj parâmetro é null e o método não é estático.
-ou-
O método não é declarado nem herdado pela classe de obj.
-ou-
Um construtor estático é invocado, e obj não é nem null uma instância da classe que declarou o construtor.
Nota: Em .NET para aplicações Windows Store ou a Portable Class Library, escolha Exception em vez disso.
Os elementos do parameters array não correspondem à assinatura do método ou construtor refletida nesta instância.
O método invocado ou construtor lança uma exceção.
-ou-
A instância atual é uma DynamicMethod que contém código não verificável. Consulte a secção "Verificação" em Observações para DynamicMethod.
O parameters array não tem o número correto de argumentos.
O chamador não tem permissão para executar o método ou construtor representado pela instância atual.
Nota: Em .NET para aplicações Windows Store ou a Portable Class Library, apanhe a exceção da classe base, MemberAccessException, em vez disso.
O tipo que declara o método é um tipo genérico aberto. Ou seja, a ContainsGenericParameters propriedade retorna true para o tipo declarante.
A instância atual é um MethodBuilder.
Exemplos
O exemplo de código seguinte demonstra a pesquisa dinâmica de métodos usando reflexão. Note que não pode usar o MethodInfo objeto da classe base para invocar o método sobreposto na classe derivada, porque a binding tardia não consegue resolver sobrescrições.
using System;
using System.Reflection;
public class MagicClass
{
private int magicBaseValue;
public MagicClass()
{
magicBaseValue = 9;
}
public int ItsMagic(int preMagic)
{
return preMagic * magicBaseValue;
}
}
public class TestMethodInfo
{
public static void Main()
{
// Get the constructor and create an instance of MagicClass
Type magicType = Type.GetType("MagicClass");
ConstructorInfo magicConstructor = magicType.GetConstructor(Type.EmptyTypes);
object magicClassObject = magicConstructor.Invoke(new object[]{});
// Get the ItsMagic method and invoke with a parameter value of 100
MethodInfo magicMethod = magicType.GetMethod("ItsMagic");
object magicValue = magicMethod.Invoke(magicClassObject, new object[]{100});
Console.WriteLine("MethodInfo.Invoke() Example\n");
Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
}
}
// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900
Imports System.Reflection
Public Class MagicClass
Private magicBaseValue As Integer
Public Sub New()
magicBaseValue = 9
End Sub
Public Function ItsMagic(preMagic As Integer) As Integer
Return preMagic * magicBaseValue
End Function
End Class
Public Class TestMethodInfo
Public Shared Sub Main()
' Get the constructor and create an instance of MagicClass
Dim magicType As Type = Type.GetType("MagicClass")
Dim magicConstructor As ConstructorInfo = magicType.GetConstructor(Type.EmptyTypes)
Dim magicClassObject As Object = magicConstructor.Invoke(New Object(){})
' Get the ItsMagic method and invoke with a parameter value of 100
Dim magicMethod As MethodInfo = magicType.GetMethod("ItsMagic")
Dim magicValue As Object = magicMethod.Invoke(magicClassObject, New Object(){100})
Console.WriteLine("MethodInfo.Invoke() Example" + Environment.NewLine)
Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue)
End Sub
End Class
' The example program gives the following output:
'
' MethodInfo.Invoke() Example
'
' MagicClass.ItsMagic() returned: 900
Observações
Este é um método de conveniência que chama sobrecarga ao Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) método, passando Default para invokeAttr e null para binder e culture.
Se o método invocado lançar uma exceção, o Exception.GetBaseException método devolve a exceção de origem.
Para invocar um método estático usando o seu MethodInfo objeto, passa null por obj.
Note
Se esta sobrecarga de métodos for usada para invocar um construtor de instância, o objeto fornecido para obj é reinicializado; ou seja, todos os inicializadores de instância são executados. O valor de retorno é null. Se um construtor de classe for invocado, a classe é reinicializada; ou seja, todos os inicializadores de classe são executados. O valor de retorno é null.
Note
Este método pode ser usado para aceder a membros não públicos se o chamador tiver recebido ReflectionPermission a ReflectionPermissionFlag.RestrictedMemberAccess bandeira e se o conjunto de concessões dos membros privados estiver restrito ao conjunto de concessão do chamador, ou a um subconjunto destes. (Ver Considerações de Segurança para Reflexão.) Para usar esta funcionalidade, a sua aplicação deve direcionar-se para o .NET Framework 3.5 ou posterior.
Se um parâmetro do método refletido for um tipo de valor, e o argumento correspondente em parameters for null, o tempo de execução passa por uma instância inicializada a zero do tipo de valor.
Ver também
- BindingFlags
- Missing
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
Aplica-se a
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)
Quando sobrescrito numa classe derivada, invoca o método ou construtor refletido com os parâmetros dados.
public:
abstract System::Object ^ Invoke(System::Object ^ obj, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ parameters, System::Globalization::CultureInfo ^ culture);public abstract object Invoke(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);abstract member Invoke : obj * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo -> objPublic MustOverride Function Invoke (obj As Object, invokeAttr As BindingFlags, binder As Binder, parameters As Object(), culture As CultureInfo) As ObjectParâmetros
- obj
- Object
O objeto sobre o qual invocar o método ou construtor. Se um método for estático, este argumento é ignorado. Se um construtor for estático, este argumento deve ser null ou uma instância da classe que define o construtor.
- invokeAttr
- BindingFlags
Uma máscara de bits que é uma combinação de 0 ou mais flags de bits de BindingFlags.
- binder
- Binder
Um objeto que permite a vinculação, coerção de tipos de argumentos, invocação de membros e recuperação de MemberInfo objetos através de reflexão. Se binder for null, utiliza-se o dossier padrão.
- parameters
- Object[]
Uma lista de argumentos para o método ou construtor invocado. Trata-se de um array de objetos com o mesmo número, ordem e tipo que os parâmetros do método ou construtor a invocar. Se não houver parâmetros, isto deveria ser null.
Se o método ou construtor representado por esta instância tomar um parâmetro ByRef, não é necessário nenhum atributo especial para esse parâmetro para invocar o método ou construtor usando essa função. Qualquer objeto neste array que não esteja explicitamente inicializado com um valor conterá o valor padrão para esse tipo de objeto. Para elementos do tipo de referência, este valor é null. Para elementos do tipo valor, este valor é 0, 0,0 ou false, dependendo do tipo específico de elemento.
- culture
- CultureInfo
Um exemplo de CultureInfo usado para governar a coerção de tipos. Se for null, usa-se para CultureInfo a thread atual. (Isto é necessário para converter uma cadeia que representa 1000 num Double valor, por exemplo, uma vez que 1000 é representado de forma diferente por diferentes culturas.)
Devoluções
E contendo Object o valor de retorno do método invocado, ou null no caso de um construtor, ou null se o tipo de retorno do método for void. Antes de chamar o método ou construtor, Invoke verifica se o utilizador tem permissão de acesso e verifica se os parâmetros são válidos.
Implementações
Exceções
O obj parâmetro é null e o método não é estático.
-ou-
O método não é declarado nem herdado pela classe de obj.
-ou-
Um construtor estático é invocado, e obj não é nem null uma instância da classe que declarou o construtor.
O tipo do parameters parâmetro não corresponde à assinatura do método ou construtor refletida nesta instância.
O parameters array não tem o número correto de argumentos.
O método invocado ou construtor lança uma exceção.
O chamador não tem permissão para executar o método ou construtor representado pela instância atual.
O tipo que declara o método é um tipo genérico aberto. Ou seja, a ContainsGenericParameters propriedade retorna true para o tipo declarante.
Exemplos
O exemplo seguinte demonstra todos os membros da System.Reflection.Binder classe usando uma sobrecarga de Type.InvokeMember. O método CanConvertFrom privado encontra tipos compatíveis para um dado tipo. Para outro exemplo de invocação de membros num cenário de ligação personalizada, veja Carregamento Dinâmico e Utilização de Tipos.
using System;
using System.Reflection;
using System.Globalization;
public class MyBinder : Binder
{
public MyBinder() : base()
{
}
private class BinderState
{
public object[] args;
}
public override FieldInfo BindToField(
BindingFlags bindingAttr,
FieldInfo[] match,
object value,
CultureInfo culture
)
{
if(match == null)
throw new ArgumentNullException("match");
// Get a field for which the value parameter can be converted to the specified field type.
for(int i = 0; i < match.Length; i++)
if(ChangeType(value, match[i].FieldType, culture) != null)
return match[i];
return null;
}
public override MethodBase BindToMethod(
BindingFlags bindingAttr,
MethodBase[] match,
ref object[] args,
ParameterModifier[] modifiers,
CultureInfo culture,
string[] names,
out object state
)
{
// Store the arguments to the method in a state object.
BinderState myBinderState = new BinderState();
object[] arguments = new Object[args.Length];
args.CopyTo(arguments, 0);
myBinderState.args = arguments;
state = myBinderState;
if(match == null)
throw new ArgumentNullException();
// Find a method that has the same parameters as those of the args parameter.
for(int i = 0; i < match.Length; i++)
{
// Count the number of parameters that match.
int count = 0;
ParameterInfo[] parameters = match[i].GetParameters();
// Go on to the next method if the number of parameters do not match.
if(args.Length != parameters.Length)
continue;
// Match each of the parameters that the user expects the method to have.
for(int j = 0; j < args.Length; j++)
{
// If the names parameter is not null, then reorder args.
if(names != null)
{
if(names.Length != args.Length)
throw new ArgumentException("names and args must have the same number of elements.");
for(int k = 0; k < names.Length; k++)
if(String.Compare(parameters[j].Name, names[k].ToString()) == 0)
args[j] = myBinderState.args[k];
}
// Determine whether the types specified by the user can be converted to the parameter type.
if(ChangeType(args[j], parameters[j].ParameterType, culture) != null)
count += 1;
else
break;
}
// Determine whether the method has been found.
if(count == args.Length)
return match[i];
}
return null;
}
public override object ChangeType(
object value,
Type myChangeType,
CultureInfo culture
)
{
// Determine whether the value parameter can be converted to a value of type myType.
if(CanConvertFrom(value.GetType(), myChangeType))
// Return the converted object.
return Convert.ChangeType(value, myChangeType);
else
// Return null.
return null;
}
public override void ReorderArgumentArray(
ref object[] args,
object state
)
{
// Return the args that had been reordered by BindToMethod.
((BinderState)state).args.CopyTo(args, 0);
}
public override MethodBase SelectMethod(
BindingFlags bindingAttr,
MethodBase[] match,
Type[] types,
ParameterModifier[] modifiers
)
{
if(match == null)
throw new ArgumentNullException("match");
for(int i = 0; i < match.Length; i++)
{
// Count the number of parameters that match.
int count = 0;
ParameterInfo[] parameters = match[i].GetParameters();
// Go on to the next method if the number of parameters do not match.
if(types.Length != parameters.Length)
continue;
// Match each of the parameters that the user expects the method to have.
for(int j = 0; j < types.Length; j++)
// Determine whether the types specified by the user can be converted to parameter type.
if(CanConvertFrom(types[j], parameters[j].ParameterType))
count += 1;
else
break;
// Determine whether the method has been found.
if(count == types.Length)
return match[i];
}
return null;
}
public override PropertyInfo SelectProperty(
BindingFlags bindingAttr,
PropertyInfo[] match,
Type returnType,
Type[] indexes,
ParameterModifier[] modifiers
)
{
if(match == null)
throw new ArgumentNullException("match");
for(int i = 0; i < match.Length; i++)
{
// Count the number of indexes that match.
int count = 0;
ParameterInfo[] parameters = match[i].GetIndexParameters();
// Go on to the next property if the number of indexes do not match.
if(indexes.Length != parameters.Length)
continue;
// Match each of the indexes that the user expects the property to have.
for(int j = 0; j < indexes.Length; j++)
// Determine whether the types specified by the user can be converted to index type.
if(CanConvertFrom(indexes[j], parameters[j].ParameterType))
count += 1;
else
break;
// Determine whether the property has been found.
if(count == indexes.Length)
// Determine whether the return type can be converted to the properties type.
if(CanConvertFrom(returnType, match[i].PropertyType))
return match[i];
else
continue;
}
return null;
}
// Determines whether type1 can be converted to type2. Check only for primitive types.
private bool CanConvertFrom(Type type1, Type type2)
{
if(type1.IsPrimitive && type2.IsPrimitive)
{
TypeCode typeCode1 = Type.GetTypeCode(type1);
TypeCode typeCode2 = Type.GetTypeCode(type2);
// If both type1 and type2 have the same type, return true.
if(typeCode1 == typeCode2)
return true;
// Possible conversions from Char follow.
if(typeCode1 == TypeCode.Char)
switch(typeCode2)
{
case TypeCode.UInt16 : return true;
case TypeCode.UInt32 : return true;
case TypeCode.Int32 : return true;
case TypeCode.UInt64 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from Byte follow.
if(typeCode1 == TypeCode.Byte)
switch(typeCode2)
{
case TypeCode.Char : return true;
case TypeCode.UInt16 : return true;
case TypeCode.Int16 : return true;
case TypeCode.UInt32 : return true;
case TypeCode.Int32 : return true;
case TypeCode.UInt64 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from SByte follow.
if(typeCode1 == TypeCode.SByte)
switch(typeCode2)
{
case TypeCode.Int16 : return true;
case TypeCode.Int32 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from UInt16 follow.
if(typeCode1 == TypeCode.UInt16)
switch(typeCode2)
{
case TypeCode.UInt32 : return true;
case TypeCode.Int32 : return true;
case TypeCode.UInt64 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from Int16 follow.
if(typeCode1 == TypeCode.Int16)
switch(typeCode2)
{
case TypeCode.Int32 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from UInt32 follow.
if(typeCode1 == TypeCode.UInt32)
switch(typeCode2)
{
case TypeCode.UInt64 : return true;
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from Int32 follow.
if(typeCode1 == TypeCode.Int32)
switch(typeCode2)
{
case TypeCode.Int64 : return true;
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from UInt64 follow.
if(typeCode1 == TypeCode.UInt64)
switch(typeCode2)
{
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from Int64 follow.
if(typeCode1 == TypeCode.Int64)
switch(typeCode2)
{
case TypeCode.Single : return true;
case TypeCode.Double : return true;
default : return false;
}
// Possible conversions from Single follow.
if(typeCode1 == TypeCode.Single)
switch(typeCode2)
{
case TypeCode.Double : return true;
default : return false;
}
}
return false;
}
}
public class MyClass1
{
public short myFieldB;
public int myFieldA;
public void MyMethod(long i, char k)
{
Console.WriteLine("\nThis is MyMethod(long i, char k)");
}
public void MyMethod(long i, long j)
{
Console.WriteLine("\nThis is MyMethod(long i, long j)");
}
}
public class Binder_Example
{
public static void Main()
{
// Get the type of MyClass1.
Type myType = typeof(MyClass1);
// Get the instance of MyClass1.
MyClass1 myInstance = new MyClass1();
Console.WriteLine("\nDisplaying the results of using the MyBinder binder.\n");
// Get the method information for MyMethod.
MethodInfo myMethod = myType.GetMethod("MyMethod", BindingFlags.Public | BindingFlags.Instance,
new MyBinder(), new Type[] {typeof(short), typeof(short)}, null);
Console.WriteLine(myMethod);
// Invoke MyMethod.
myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, new MyBinder(), new Object[] {(int)32, (int)32}, CultureInfo.CurrentCulture);
}
}
Imports System.Reflection
Imports System.Globalization
Public Class MyBinder
Inherits Binder
Public Sub New()
MyBase.new()
End Sub
Private Class BinderState
Public args() As Object
End Class
Public Overrides Function BindToField(ByVal bindingAttr As BindingFlags, ByVal match() As FieldInfo, ByVal value As Object, ByVal culture As CultureInfo) As FieldInfo
If match Is Nothing Then
Throw New ArgumentNullException("match")
End If
' Get a field for which the value parameter can be converted to the specified field type.
Dim i As Integer
For i = 0 To match.Length - 1
If Not (ChangeType(value, match(i).FieldType, culture) Is Nothing) Then
Return match(i)
End If
Next i
Return Nothing
End Function 'BindToField
Public Overrides Function BindToMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByRef args() As Object, ByVal modifiers() As ParameterModifier, ByVal culture As CultureInfo, ByVal names() As String, ByRef state As Object) As MethodBase
' Store the arguments to the method in a state object.
Dim myBinderState As New BinderState()
Dim arguments() As Object = New [Object](args.Length) {}
args.CopyTo(arguments, 0)
myBinderState.args = arguments
state = myBinderState
If match Is Nothing Then
Throw New ArgumentNullException()
End If
' Find a method that has the same parameters as those of args.
Dim i As Integer
For i = 0 To match.Length - 1
' Count the number of parameters that match.
Dim count As Integer = 0
Dim parameters As ParameterInfo() = match(i).GetParameters()
' Go on to the next method if the number of parameters do not match.
If args.Length <> parameters.Length Then
GoTo ContinueFori
End If
' Match each of the parameters that the user expects the method to have.
Dim j As Integer
For j = 0 To args.Length - 1
' If names is not null, then reorder args.
If Not (names Is Nothing) Then
If names.Length <> args.Length Then
Throw New ArgumentException("names and args must have the same number of elements.")
End If
Dim k As Integer
For k = 0 To names.Length - 1
If String.Compare(parameters(j).Name, names(k).ToString()) = 0 Then
args(j) = myBinderState.args(k)
End If
Next k
End If ' Determine whether the types specified by the user can be converted to parameter type.
If Not (ChangeType(args(j), parameters(j).ParameterType, culture) Is Nothing) Then
count += 1
Else
Exit For
End If
Next j
' Determine whether the method has been found.
If count = args.Length Then
Return match(i)
End If
ContinueFori:
Next i
Return Nothing
End Function 'BindToMethod
Public Overrides Function ChangeType(ByVal value As Object, ByVal myChangeType As Type, ByVal culture As CultureInfo) As Object
' Determine whether the value parameter can be converted to a value of type myType.
If CanConvertFrom(value.GetType(), myChangeType) Then
' Return the converted object.
Return Convert.ChangeType(value, myChangeType)
' Return null.
Else
Return Nothing
End If
End Function 'ChangeType
Public Overrides Sub ReorderArgumentArray(ByRef args() As Object, ByVal state As Object)
'Redimension the array to hold the state values.
ReDim args(CType(state, BinderState).args.Length)
' Return the args that had been reordered by BindToMethod.
CType(state, BinderState).args.CopyTo(args, 0)
End Sub
Public Overrides Function SelectMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByVal types() As Type, ByVal modifiers() As ParameterModifier) As MethodBase
If match Is Nothing Then
Throw New ArgumentNullException("match")
End If
Dim i As Integer
For i = 0 To match.Length - 1
' Count the number of parameters that match.
Dim count As Integer = 0
Dim parameters As ParameterInfo() = match(i).GetParameters()
' Go on to the next method if the number of parameters do not match.
If types.Length <> parameters.Length Then
GoTo ContinueFori
End If
' Match each of the parameters that the user expects the method to have.
Dim j As Integer
For j = 0 To types.Length - 1
' Determine whether the types specified by the user can be converted to parameter type.
If CanConvertFrom(types(j), parameters(j).ParameterType) Then
count += 1
Else
Exit For
End If
Next j ' Determine whether the method has been found.
If count = types.Length Then
Return match(i)
End If
ContinueFori:
Next i
Return Nothing
End Function 'SelectMethod
Public Overrides Function SelectProperty(ByVal bindingAttr As BindingFlags, ByVal match() As PropertyInfo, ByVal returnType As Type, ByVal indexes() As Type, ByVal modifiers() As ParameterModifier) As PropertyInfo
If match Is Nothing Then
Throw New ArgumentNullException("match")
End If
Dim i As Integer
For i = 0 To match.Length - 1
' Count the number of indexes that match.
Dim count As Integer = 0
Dim parameters As ParameterInfo() = match(i).GetIndexParameters()
' Go on to the next property if the number of indexes do not match.
If indexes.Length <> parameters.Length Then
GoTo ContinueFori
End If
' Match each of the indexes that the user expects the property to have.
Dim j As Integer
For j = 0 To indexes.Length - 1
' Determine whether the types specified by the user can be converted to index type.
If CanConvertFrom(indexes(j), parameters(j).ParameterType) Then
count += 1
Else
Exit For
End If
Next j ' Determine whether the property has been found.
If count = indexes.Length Then
' Determine whether the return type can be converted to the properties type.
If CanConvertFrom(returnType, match(i).PropertyType) Then
Return match(i)
Else
GoTo ContinueFori
End If
End If
ContinueFori:
Next i
Return Nothing
End Function 'SelectProperty
' Determine whether type1 can be converted to type2. Check only for primitive types.
Private Function CanConvertFrom(ByVal type1 As Type, ByVal type2 As Type) As Boolean
If type1.IsPrimitive And type2.IsPrimitive Then
Dim typeCode1 As TypeCode = Type.GetTypeCode(type1)
Dim typeCode2 As TypeCode = Type.GetTypeCode(type2)
' If both type1 and type2 have same type, return true.
If typeCode1 = typeCode2 Then
Return True
End If ' Possible conversions from Char follow.
If typeCode1 = TypeCode.Char Then
Select Case typeCode2
Case TypeCode.UInt16
Return True
Case TypeCode.UInt32
Return True
Case TypeCode.Int32
Return True
Case TypeCode.UInt64
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from Byte follow.
If typeCode1 = TypeCode.Byte Then
Select Case typeCode2
Case TypeCode.Char
Return True
Case TypeCode.UInt16
Return True
Case TypeCode.Int16
Return True
Case TypeCode.UInt32
Return True
Case TypeCode.Int32
Return True
Case TypeCode.UInt64
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from SByte follow.
If typeCode1 = TypeCode.SByte Then
Select Case typeCode2
Case TypeCode.Int16
Return True
Case TypeCode.Int32
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from UInt16 follow.
If typeCode1 = TypeCode.UInt16 Then
Select Case typeCode2
Case TypeCode.UInt32
Return True
Case TypeCode.Int32
Return True
Case TypeCode.UInt64
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from Int16 follow.
If typeCode1 = TypeCode.Int16 Then
Select Case typeCode2
Case TypeCode.Int32
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from UInt32 follow.
If typeCode1 = TypeCode.UInt32 Then
Select Case typeCode2
Case TypeCode.UInt64
Return True
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from Int32 follow.
If typeCode1 = TypeCode.Int32 Then
Select Case typeCode2
Case TypeCode.Int64
Return True
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from UInt64 follow.
If typeCode1 = TypeCode.UInt64 Then
Select Case typeCode2
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from Int64 follow.
If typeCode1 = TypeCode.Int64 Then
Select Case typeCode2
Case TypeCode.Single
Return True
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If ' Possible conversions from Single follow.
If typeCode1 = TypeCode.Single Then
Select Case typeCode2
Case TypeCode.Double
Return True
Case Else
Return False
End Select
End If
End If
Return False
End Function 'CanConvertFrom
End Class
Public Class MyClass1
Public myFieldB As Short
Public myFieldA As Integer
Public Overloads Sub MyMethod(ByVal i As Long, ByVal k As Char)
Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, char k).")
End Sub
Public Overloads Sub MyMethod(ByVal i As Long, ByVal j As Long)
Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, long j).")
End Sub
End Class
Public Class Binder_Example
Public Shared Sub Main()
' Get the type of MyClass1.
Dim myType As Type = GetType(MyClass1)
' Get the instance of MyClass1.
Dim myInstance As New MyClass1()
Console.WriteLine(ControlChars.Cr & "Displaying the results of using the MyBinder binder.")
Console.WriteLine()
' Get the method information for MyMethod.
Dim myMethod As MethodInfo = myType.GetMethod("MyMethod", BindingFlags.Public Or BindingFlags.Instance, New MyBinder(), New Type() {GetType(Short), GetType(Short)}, Nothing)
Console.WriteLine(MyMethod)
' Invoke MyMethod.
myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, New MyBinder(), New [Object]() {CInt(32), CInt(32)}, CultureInfo.CurrentCulture)
End Sub
End Class
Observações
Este método invoca dinamicamente o método reflectido por esta instância em obj, e transmite os parâmetros especificados. Se o método for estático, o obj parâmetro é ignorado. Para métodos não estáticos, obj deve ser uma instância de uma classe que herda ou declara o método e deve ser do mesmo tipo que esta classe. Se o método não tiver parâmetros, o valor de parameters deve ser null. Caso contrário, o número, tipo e ordem dos elementos em parameters devem ser idênticos ao número, tipo e ordem dos parâmetros para o método refletido por esta instância.
Não pode omitir parâmetros opcionais nas chamadas para Invoke. Para invocar um método e omitir parâmetros opcionais, chame Type.InvokeMember em vez disso.
Note
Se esta sobrecarga de métodos for usada para invocar um construtor de instância, o objeto fornecido para obj é reinicializado; ou seja, todos os inicializadores de instância são executados. O valor de retorno é null. Se um construtor de classe for invocado, a classe é reinicializada; ou seja, todos os inicializadores de classe são executados. O valor de retorno é null.
Para parâmetros primitivos pass-by-value, é realizado o alargamento normal (Int16 -> Int32, por exemplo). Para parâmetros de referência pass-by-value, é permitido alargamento normal de referência (de classe derivada para classe base, e de classe base para tipo de interface). No entanto, para parâmetros primitivos pass-by-reference, os tipos devem corresponder exatamente. Para parâmetros de referência pass-by-reference, o alargamento normal ainda se aplica.
Por exemplo, se o método refletido por esta instância for declarado como public boolean Compare(String a, String b), então parameters deve ser um array de Objects com comprimento 2 tal que parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").
Se um parâmetro do método atual for um tipo de valor, e o argumento correspondente em parameters for null, o tempo de execução passa por uma instância zero-inicializada do tipo de valor.
A reflexão utiliza a pesquisa dinâmica de métodos ao invocar métodos virtuais. Por exemplo, suponha que a classe B herda da classe A e ambas implementam um método virtual chamado M. Agora suponha que tem um MethodInfo objeto que representa M na classe A. Se usar o Invoke método para invocar M num objeto do tipo B, então a reflexão usará a implementação dada pela classe B. Mesmo que o objeto do tipo B seja lançado para A, a implementação dada pela classe B é usada (ver exemplo de código abaixo).
Por outro lado, se o método for não virtual, então a reflexão usará a implementação dada pelo tipo de onde o MethodInfo foi obtido, independentemente do tipo do objeto passado como alvo.
As restrições de acesso são ignoradas para código totalmente confiável. Ou seja, construtores privados, métodos, campos e propriedades podem ser acedidos e invocados via reflexão sempre que o código é totalmente confiável.
Se o método invocado lançar uma exceção, o Exception.GetBaseException método devolve a exceção de origem.
Note
Este método pode ser usado para aceder a membros não públicos se o chamador tiver recebido ReflectionPermission a ReflectionPermissionFlag.RestrictedMemberAccess bandeira e se o conjunto de concessões dos membros privados estiver restrito ao conjunto de concessão do chamador, ou a um subconjunto destes. (Ver Considerações de Segurança para Reflexão.) Para usar esta funcionalidade, a sua aplicação deve direcionar-se para o .NET Framework 3.5 ou posterior.
Ver também
- InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])
- Carregamento e Utilização Dinâmica dos Tipos