IReflect.InvokeMember Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Reflection
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Richiama un membro specificato.

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

Parametri

name
String

Nome del membro da ricercare.

invokeAttr
BindingFlags

Uno degli attributi di chiamata di BindingFlags. Il parametro invokeAttrpuò essere un costruttore, un metodo, una proprietà o un campo. È necessario specificare un attributo di chiamata appropriato. Richiamare il membro predefinito di una classe passando una stringa vuota ("") come nome del membro.

binder
Binder

Uno dei flag di bit di BindingFlags. Implementa l'oggetto Binder, contenente le proprietà relative a questo metodo.

target
Object

Oggetto su cui richiamare il membro specificato. Il parametro viene ignorato nel caso dei membri statici.

args
Object[]

Matrice di oggetti che contiene il numero, l'ordine e il tipo dei parametri del membro da richiamare. Si tratta di una matrice vuota se non sono disponibili parametri.

modifiers
ParameterModifier[]

Matrice di oggetti ParameterModifier. Questa matrice ha la stessa lunghezza del parametro args che rappresenta gli attributi degli argomenti del membro richiamato nei metadati. Un parametro può avere i seguenti attributi: pdIn, pdOut, pdRetval, pdOptional e pdHasDefault. Questi rappresentano rispettivamente [In], [Out], [retval], [optional] e un parametro predefinito. Questi attributi sono utilizzati da vari servizi di interoperabilità.

culture
CultureInfo

Istanza di CultureInfo usata per regolare la coercizione dei tipi. Ad esempio, culture converte una stringa che rappresenta il numero 1000 in un valore Double, dal momento che 1000 è rappresentato in modo diverso nelle varie impostazioni cultura. Se questo parametro è null, viene utilizzato l'oggetto CultureInfo per il thread corrente.

namedParameters
String[]

Matrice di parametri di tipo stringa.

Restituisce

Object

Membro specificato.

Eccezioni

ArgumentException

Sono stati specificati più argomenti per un metodo set di campo.

MissingFieldException

Non è possibile trovare il campo o la proprietà.

MissingMethodException

Impossibile trovare il metodo.

SecurityException

Viene richiamato un membro privato senza l'oggetto ReflectionPermission necessario.

Esempio

Nell'esempio seguente viene ottenuto il valore della Now proprietà .

#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

Commenti

Il metodo da richiamare deve essere accessibile e fornire massima corrispondenza con l'elenco di argomenti specificato, in conformità ai vincoli del binder e degli attributi di chiamata specificati.

Viene richiamato un metodo se il numero di parametri nella dichiarazione del metodo equivale al numero di argomenti nell'elenco di argomenti specificato e il tipo di ogni argomento può essere convertito dal binder al tipo del parametro.

Nota

La matrice di modificatori di parametri passata al InvokeMember metodo deve contenere un singolo modificatore di parametri. Solo il primo modificatore di parametri viene considerato quando si determina quale argomento deve essere passato da riferimento quando esposto a COM.

Il binder trova tutti i metodi corrispondenti, in base al tipo di binding richiesto (BindingFlags.InvokeMethod, GetPropertiese così via). Il set di metodi viene filtrato dal nome, dal numero di argomenti e da un set di modificatori di ricerca definiti nel binder. Dopo aver selezionato il metodo, viene richiamato e l'accessibilità viene selezionata a quel punto. La ricerca può controllare quale set di metodi viene eseguito la ricerca in base all'attributo di accessibilità associato al metodo . BindToMethod seleziona il metodo da richiamare. Il binder predefinito seleziona la corrispondenza più specifica.

Le restrizioni di accesso vengono ignorate per il codice completamente attendibile. Ovvero, i costruttori privati, i metodi, i campi e le proprietà possono essere accessibili e richiamati tramite reflection ogni volta che il codice è completamente attendibile.

Si applica a

Vedi anche