Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Type.InvokeMember (String, BindingFlags, Binder, Object, Object[])

 

Data di pubblicazione: ottobre 2016

Chiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti specificato.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public object InvokeMember(
	string name,
	BindingFlags invokeAttr,
	Binder binder,
	object target,
	object[] args
)

Parametri

name
Type: System.String

Stringa che contiene il nome del costruttore, del metodo, della proprietà o del membro del campo da richiamare.

-oppure-

Stringa vuota ("") per richiamare il membro predefinito.

-oppure-

Per i membri IDispatch, stringa che rappresenta DispID, ad esempio "[DispID=3]".

invokeAttr
Type: System.Reflection.BindingFlags

Maschera di bit costituita da uno o più BindingFlags che consente di specificare le modalità di esecuzione della ricerca. L'accesso può essere uno dei BindingFlags, ad esempio Public, NonPublic, Private, InvokeMethod, GetField e così via. Il tipo di ricerca non deve essere specificato. Se il tipo di ricerca viene omesso, vengono usati BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static.

binder
Type: System.Reflection.Binder

Oggetto che definisce una serie di proprietà e permette il binding, che può implicare la scelta di un metodo di overload, la coercizione di tipi di argomento e la chiamata di un membro mediante reflection.

-oppure-

Riferimento Null (Nothing in Visual Basic) per l'uso di DefaultBinder. Si noti che potrebbe essere necessario definire in modo esplicito un oggetto Binder per richiamare correttamente overload di metodo con argomenti variabili.

target
Type: System.Object

Oggetto su cui richiamare il membro specificato.

args
Type: System.Object[]

Matrice che contiene gli argomenti da passare al membro da richiamare.

Valore restituito

Type: System.Object

Oggetto che rappresenta il valore restituito di un membro richiamato.

Exception Condition
ArgumentNullException

invokeAttr non contiene CreateInstance e name è null.

ArgumentException

invokeAttr non è un attributo valido di BindingFlags.

-oppure-

invokeAttr non contiene uno dei flag di binding seguenti: InvokeMethod, CreateInstance, GetField, SetField, GetProperty o SetProperty.

-oppure-

invokeAttr contiene CreateInstance in combinazione con InvokeMethod, GetField, SetField, GetProperty o SetProperty.

-oppure-

invokeAttr contiene sia GetField che SetField.

-oppure-

invokeAttr contiene sia GetProperty che SetProperty.

-oppure-

invokeAttr contiene InvokeMethod in combinazione con SetField o SetProperty.

-oppure-

invokeAttr contiene SetField e args include più elementi.

-oppure-

Questo metodo è stato chiamato su un oggetto COM e uno dei flag di binding seguenti non è stato passato: BindingFlags.InvokeMethod, BindingFlags.GetProperty, BindingFlags.SetProperty, BindingFlags.PutDispProperty o BindingFlags.PutRefDispProperty.

-oppure-

Una delle matrici di parametri denominati contiene una stringa null.

MethodAccessException

Il membro specificato è un inizializzatore di classi.

MissingFieldException

Non è possibile trovare il campo o la proprietà.

MissingMethodException

Non è possibile trovare metodi corrispondenti agli argomenti in args.

-oppure-

L'oggetto Type corrente rappresenta un tipo che contiene parametri di tipo open, ovvero ContainsGenericParameters restituisce true.

TargetException

Non è possibile richiamare il metodo specificato su target.

AmbiguousMatchException

Più di un metodo corrisponde ai criteri di binding.

NotSupportedException

Questo metodo non è attualmente supportato in .NET Compact Framework.

InvalidOperationException

Il metodo rappresentato da name include uno o più parametri di tipo generico non specificati. In altri termini, la proprietà ContainsGenericParameters del metodo restituisce true.

System_CAPS_noteNota

Non è possibile utilizzare InvokeMember per richiamare un metodo generico.

Nell'esempio BindingFlags flag del filtro può essere utilizzato per definire i membri da includere nella ricerca:

  • Specificare BindingFlags.Public per includere i membri pubblici nella ricerca.

  • Specificare BindingFlags.NonPublic per includere nella ricerca i membri non pubblici (ovvero, i membri privati e protetti).

  • Specificare BindingFlags.FlattenHierarchy per includere i membri statici nella gerarchia.

Nell'esempio BindingFlags flag di modifica consente di modificare le modalità di ricerca:

  • BindingFlags.IgnoreCase per ignorare la distinzione di name.

  • BindingFlags.DeclaredOnly Per cercare solo i membri dichiarati nel Type, non i membri sono stati ereditati.

Nell'esempio BindingFlags flag di chiamata può essere utilizzato per indicare l'azione da intraprendere con il membro:

  • CreateInstance per richiamare un costruttore. name viene ignorato. Non è valido con altri flag di chiamata.

  • InvokeMethod per richiamare un metodo, ma non un costruttore o un inizializzatore di tipo. Non valido con SetField o SetProperty. Se InvokeMethod è specificato da se stesso, BindingFlags.Public, BindingFlags.Instance, e BindingFlags.Static vengono inclusi automaticamente.

  • GetField Per ottenere il valore di un campo. Non valido con SetField.

  • SetField Per impostare il valore di un campo. Non valido con GetField.

  • GetProperty Per ottenere una proprietà. Non valido con SetProperty.

  • SetProperty Per impostare una proprietà. Non valido con GetProperty.

Per altre informazioni, vedere System.Reflection.BindingFlags.

Un metodo verrà richiamato se entrambe le condizioni seguenti sono vere:

  • Il numero di parametri nella dichiarazione del metodo è uguale al numero di argomenti in di args matrice (a meno che gli argomenti predefiniti vengono definiti sul membro e BindingFlags.OptionalParamBinding è specificato).

  • Il tipo di ciascun argomento può essere convertito dal gestore di associazione per il tipo del parametro.

Il gestore di associazione troverà tutti i metodi corrispondenti. Questi metodi vengono rilevati in base al tipo di associazione richiesta (BindingFlags valori InvokeMethod, GetProperty, e così via). Il set di metodi viene filtrato il nome, numero di argomenti e un set modificatori di ricerca definiti nel gestore di associazione.

Una volta selezionato il metodo viene richiamato. Accessibilità viene controllata a quel punto. È possibile specificare quale set di metodi vengono ricercati in base all'attributo di accessibilità associato al metodo. Il Binder.BindToMethod metodo la Binder classe è responsabile della selezione del metodo da richiamare. Il binder predefinito seleziona la corrispondenza più specifica.

Restrizioni di accesso vengono ignorate per codice completamente attendibile. ovvero costruttori privati, metodi, campi e proprietà accessibili e richiamate tramite System.Reflection ogni volta che il codice è completamente attendibile.

È possibile utilizzare Type.InvokeMember per impostare un campo a un determinato valore specificando BindingFlags.SetField. Ad esempio, se si desidera impostare un campo di istanza pubblica denominato F sulla classe C e F è un String, è possibile utilizzare codice, ad esempio:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"});

Se F è un String[], è possibile utilizzare codice, ad esempio:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}});

in modo da inizializzare il campo F alla nuova matrice. È inoltre possibile utilizzare Type.InvokeMember per impostare una posizione in una matrice fornendo l'indice del valore e quindi il valore successivo utilizzando codice simile al seguente:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"});

Stringa "z" nella matrice che contiene F alla stringa "b" verrà modificato.

Quando si richiama un IDispatch membro, è possibile specificare il DispID anziché il nome del membro, utilizzando il formato della stringa "[DispID = # #]". Ad esempio, se il DispID di MyComMethod è 3, è possibile specificare la stringa "[DispID = 3]" anziché "MyComMethod". Richiamare un membro da DispID è più veloce rispetto alla ricerca del membro in base al nome. In scenari di aggregazione complessi, talvolta il DispID è l'unico modo per richiamare il membro desiderato.

System_CAPS_noteNota

A partire dal .NET Framework 2.0 Service Pack 1, questo metodo può essere utilizzato per accedere a membri non pubblici se il chiamante sia stata concessa ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei membri non pubblici è limitato al chiamante insieme di autorizzazioni o un suo sottoinsieme. Per informazioni, vedere Security Considerations for Reflection.

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5 o versione successiva.

Nell'esempio seguente viene utilizzato InvokeMember per accedere ai membri di un tipo.

using System;
using System.Reflection;

// This sample class has a field, constructor, method, and property.
class MyType 
{
    Int32 myField;
    public MyType(ref Int32 x) {x *= 5;}
    public override String ToString() {return myField.ToString();}
    public Int32 MyProp 
    {
        get {return myField;}
        set 
        { 
            if (value < 1) 
                throw new ArgumentOutOfRangeException("value", value, "value must be > 0");
            myField = value;
        }
    }
}

class MyApp 
{
    static void Main() 
    {
        Type t = typeof(MyType);
        // Create an instance of a type.
        Object[] args = new Object[] {8};
        Console.WriteLine("The value of x before the constructor is called is {0}.", args[0]);
        Object obj = t.InvokeMember(null, 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);
        Console.WriteLine("Type: " + obj.GetType().ToString());
        Console.WriteLine("The value of x after the constructor returns is {0}.", args[0]);

        // Read and write to a field.
        t.InvokeMember("myField", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.SetField, null, obj, new Object[] {5});
        Int32 v = (Int32) t.InvokeMember("myField", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.GetField, null, obj, null);
        Console.WriteLine("myField: " + v);

        // Call a method.
        String s = (String) t.InvokeMember("ToString", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, null);
        Console.WriteLine("ToString: " + s);

        // Read and write a property. First, attempt to assign an
        // invalid value; then assign a valid value; finally, get
        // the value.
        try 
        {
            // Assign the value zero to MyProp. The Property Set 
            // throws an exception, because zero is an invalid value.
            // InvokeMember catches the exception, and throws 
            // TargetInvocationException. To discover the real cause
            // you must catch TargetInvocationException and examine
            // the inner exception. 
            t.InvokeMember("MyProp", 
                BindingFlags.DeclaredOnly | 
                BindingFlags.Public | BindingFlags.NonPublic | 
                BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {0});
        } 
        catch (TargetInvocationException e) 
        {
            // If the property assignment failed for some unexpected
            // reason, rethrow the TargetInvocationException.
            if (e.InnerException.GetType() != 
                typeof(ArgumentOutOfRangeException)) 
                throw;
            Console.WriteLine("An invalid value was assigned to MyProp.");
        }
        t.InvokeMember("MyProp", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {2});
        v = (Int32) t.InvokeMember("MyProp", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.GetProperty, null, obj, null);
        Console.WriteLine("MyProp: " + v);
    }
}

ReflectionPermission

for accessing non-public members when the grant set of the non-public members is restricted to the caller's grant set, or a subset thereof. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.RestrictedMemberAccess

ReflectionPermission

for accessing non-public members regardless of their grant set. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess

SecurityPermission

to call unmanaged code. Associated enumeration: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode

.NET Framework
Disponibile da 1.1
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Torna all'inizio
Mostra: