IReflect.InvokeMember Método

  • Referencia

Definición

Espacio de nombres:
System.Reflection
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Invoca el miembro especificado.

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, cli::array <System::Reflection::ParameterModifier> ^ modifiers, System::Globalization::CultureInfo ^ culture, cli::array <System::String ^> ^ namedParameters);
public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Reflection.ParameterModifier[]? modifiers, System.Globalization.CultureInfo? culture, string[]? namedParameters);
public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters);
abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Reflection.ParameterModifier[] * System.Globalization.CultureInfo * string[] -> obj
Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), modifiers As ParameterModifier(), culture As CultureInfo, namedParameters As String()) As Object

Parámetros

name
String

Nombre del miembro que se va a buscar.

invokeAttr
BindingFlags

Uno de los atributos de invocación BindingFlags. El parámetro invokeAttr puede ser un constructor, método, propiedad o campo. Debe especificarse un atributo de invocación apropiado. Para invocar el miembro predeterminado de una clase, pase la cadena vacía ("") como nombre del miembro.

binder
Binder

Una de las marcas de bits BindingFlags. Implementa Binder, que contiene propiedades relacionadas con este método.

target
Object

Objeto donde debe invocarse al miembro especificado. Este parámetro se omite para los miembros estáticos.

args
Object[]

Matriz de objetos que contiene el número, orden y tipo de los parámetros del miembro que se va a invocar. Si no hay parámetros, es una matriz vacía.

modifiers
ParameterModifier[]

Matriz de objetos ParameterModifier. Esta matriz tiene la misma longitud que el parámetro args, que representa los atributos de argumento del miembro invocado en los metadatos. Un parámetro puede tener los siguientes atributos: pdIn, pdOut, pdRetval, pdOptional y pdHasDefault. Representan a [In], [Out], [retval], [optional] y a un parámetro predeterminado, respectivamente. Diversos servicios de interoperabilidad utilizan estos atributos.

culture
CultureInfo

Instancia de CultureInfo usada para regir la conversión de tipos. Por ejemplo, culture convierte una cadena que representa 1000 a un valor Double, ya que 1000 se representa de distinta manera en diferentes referencias culturales. Si este parámetro es null, se utiliza CultureInfo para el subproceso actual.

namedParameters
String[]

Matriz de cadenas de parámetros.

Devoluciones

Object

El miembro especificado.

Excepciones

ArgumentException

Se especifica más de un argumento para un campo set.

MissingFieldException

No se encuentran el campo o la propiedad.

MissingMethodException

No se encuentra el método.

SecurityException

Se invoca un miembro privado sin el objeto ReflectionPermission necesario.

Ejemplos

En el ejemplo siguiente se obtiene el valor de la Now propiedad .

#using <System.DLL>

using namespace System;
using namespace System::Reflection;

#define NULL 0
void main()
{
   Type^ tDate = Type::GetType( L"System.DateTime" );
   Object^ result = tDate->InvokeMember( L"Now", BindingFlags::GetProperty, nullptr, NULL, gcnew array<Object^>(0) );
   Console::WriteLine( result->ToString() );
}

using System;
using System.Reflection;

public class MainClass
{
    public static void Main(string[] args)
    {
        Type tDate = typeof(System.DateTime);
        Object result = tDate.InvokeMember("Now",
            BindingFlags.GetProperty, null, null, new Object[0]);
        Console.WriteLine(result.ToString());
    }
}

Imports System.Reflection

Public Class MainClass
    Public Overloads Shared Sub Main(ByVal args() As String)
        Dim tDate As Type = GetType(System.DateTime)
        Dim result As [Object] = tDate.InvokeMember("Now", _
            BindingFlags.GetProperty, Nothing, Nothing, New [Object](-1) {})
        Console.WriteLine(result.ToString())
    End Sub
End Class

Comentarios

El método que se va a invocar debe ser accesible y proporcionar la coincidencia más específica con la lista de argumentos dada, bajo las restricciones del enlazador y los atributos de invocación indicados.

Se invoca un método si el número de parámetros de la declaración de método es igual al número de argumentos de la lista de argumentos especificada y el enlazador puede convertir el tipo de cada argumento en el tipo del parámetro.

Nota

La matriz de modificadores de parámetro pasados al InvokeMember método debe contener un solo modificador de parámetro. Solo se considera el primer modificador de parámetro al determinar qué argumento debe pasarse por referencia cuando se expone a COM.

El enlazador busca todos los métodos coincidentes, de acuerdo con el tipo de enlace solicitado (BindingFlags.InvokeMethod, GetProperties, etc.). El conjunto de métodos se filtra por el nombre, el número de argumentos y un conjunto de modificadores de búsqueda definidos en el enlazador. Una vez seleccionado el método, se invoca y se comprueba la accesibilidad en ese momento. La búsqueda puede controlar qué conjunto de métodos se busca en función del atributo de accesibilidad asociado al método . BindToMethod selecciona el método que se va a invocar. El enlazador predeterminado selecciona la coincidencia más específica.

Las restricciones de acceso se omiten para el código de plena confianza. Es decir, se puede tener acceso a constructores privados, métodos, campos y propiedades e invocarse a través de la reflexión siempre que el código sea de plena confianza.

Se aplica a

Consulte también