Type.InvokeMember Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Richiama un membro specifico dell'oggetto Type corrente.

Overload

InvokeMember(String, BindingFlags, Binder, Object, Object[])	Chiama il membro specificato, usando i vincoli di associazione specificati e associando l'elenco di argomenti specificato.
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Chiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti specificati e le impostazioni cultura.
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Quando ne viene eseguito l'override in una classe derivata, richiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti, i modificatori e le impostazioni cultura specificati.

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Origine:: Type.cs

Origine:: Type.cs

Origine:: Type.cs

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

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);

public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);

public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args);

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

member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj

abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj

Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object()) As Object

Parametri

name: 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: BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la 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: 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: Object

Oggetto su cui richiamare il membro specificato.

args: Object[]

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

Restituisce

Object

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Eccezioni

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.

Esempio

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

using namespace System;
using namespace System::Reflection;

// This sample class has a field, constructor, method, and property.
ref class MyType
{
private:
   Int32 myField;

public:
   MyType( interior_ptr<Int32> x )
   {
       *x *= 5;
   }

   virtual String^ ToString() override
   {
      return myField.ToString();
   }

   property Int32 MyProp 
   {
      Int32 get()
      {
         return myField;
      }

      void set( Int32 value )
      {
         if ( value < 1 )
                  throw gcnew ArgumentOutOfRangeException( "value",value,"value must be > 0" );

         myField = value;
      }
   }
};

int main()
{
   Type^ t = MyType::typeid;

   // Create an instance of a type.
   array<Object^>^args = {8};
   Console::WriteLine( "The value of x before the constructor is called is {0}.", args[ 0 ] );
   Object^ obj = t->InvokeMember( nullptr, static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, nullptr, args );
   Console::WriteLine( "Type: {0}", obj->GetType() );
   Console::WriteLine( "The value of x after the constructor returns is {0}.", args[ 0 ] );

   // Read and write to a field.
   array<Object^>^obj5 = {5};
   t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetField), nullptr, obj, obj5 );
   Int32 v = safe_cast<Int32>(t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetField), nullptr, obj, nullptr ));
   Console::WriteLine( "myField: {0}", v );

   // Call a method.
   String^ s = safe_cast<String^>(t->InvokeMember( "ToString", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::InvokeMethod), nullptr, obj, nullptr ));
   Console::WriteLine( "ToString: {0}", 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. 
      array<Object^>^obj0 = {(int^)0};
      t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj0 );
   }
   catch ( TargetInvocationException^ e ) 
   {
      // If the property assignment failed for some unexpected
      // reason, rethrow the TargetInvocationException.
      if ( e->InnerException->GetType() != ArgumentOutOfRangeException::typeid )
            throw;

      Console::WriteLine( "An invalid value was assigned to MyProp." );
   }

   array<Object^>^obj2 = {2};
   t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj2 );
   v =  safe_cast<Int32>(t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetProperty), nullptr, obj, nullptr ));
   Console::WriteLine( "MyProp: {0}", v );
}

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

open System
open System.Reflection

// This sample class has a field, constructor, method, and property.
type MyType() =
    let mutable myField = 0

    member _.MyType(x: int byref) =
        x <- x * 5
    
    override _.ToString() =
        string myField
    
    member _.MyProp
        with get () = myField
        and set value =
            if value < 1 then
                raise (ArgumentOutOfRangeException("value", value, "value must be > 0"))
            myField <- value

let t = typeof<MyType>
// Create an instance of a type.
let args = Array.zeroCreate<obj> 8
printfn $"The value of x before the constructor is called is {args[0]}."
let obj = t.InvokeMember(null,
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.CreateInstance, null, null, args)
printfn $"Type: {obj.GetType()}"
printfn $"The value of x after the constructor returns is {args[0]}."

// Read and write to a field.
t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetField, null, obj, Array.zeroCreate<obj> 5) |> ignore
let v = t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetField, null, obj, null) :?> int
printfn $"myField: {v}"

// Call a method.
let s = t.InvokeMember("ToString",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.InvokeMethod, null, obj, null) :?> string
printfn $"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, Array.zeroCreate<obj> 0) |> ignore
with :? TargetInvocationException as e ->
    // If the property assignment failed for some unexpected
    // reason, rethrow the TargetInvocationException.
    if e.InnerException.GetType() <> typeof<ArgumentOutOfRangeException> then
        reraise ()
    printfn "An invalid value was assigned to MyProp."
t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetProperty, null, obj, Array.zeroCreate<obj> 2) |> ignore
let v2 = t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetProperty, null, obj, null)
printfn $"MyProp: {v2}"

Imports System.Reflection

' This sample class has a field, constructor, method, and property.
Class MyType
    Private myField As Int32

    Public Sub New(ByRef x As Int32)
        x *= 5
    End Sub

    Public Overrides Function ToString() As [String]
        Return myField.ToString()
    End Function 'ToString

    Public Property MyProp() As Int32
        Get
            Return myField
        End Get
        Set(ByVal Value As Int32)
            If Value < 1 Then
                Throw New ArgumentOutOfRangeException("value", Value, "value must be > 0")
            End If
            myField = Value
        End Set
    End Property
End Class

Class MyApp

    Shared Sub Main()
        Dim t As Type = GetType(MyType)
        ' Create an instance of a type.
        Dim args() As [Object] = {8}
        Console.WriteLine("The value of x before the constructor is called is {0}.", args(0))
        Dim obj As [Object] = t.InvokeMember(Nothing, BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.CreateInstance, Nothing, Nothing, args)
        Console.WriteLine("Type: {0}", 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 Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetField, Nothing, obj, New [Object]() {5})
        Dim v As Int32 = CType(t.InvokeMember("myField", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetField, Nothing, obj, Nothing), Int32)
        Console.WriteLine("myField: {0}", v)

        ' Call a method.
        Dim s As [String] = CType(t.InvokeMember("ToString", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.InvokeMethod, Nothing, obj, Nothing), [String])
        Console.WriteLine("ToString: {0}", 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 Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {0})
        Catch e As TargetInvocationException
            ' If the property assignment failed for some unexpected
            ' reason, rethrow the TargetInvocationException.
            If Not e.InnerException.GetType() Is GetType(ArgumentOutOfRangeException) Then
                Throw
            End If
            Console.WriteLine("An invalid value was assigned to MyProp.")
        End Try
        t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {2})
        v = CType(t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetProperty, Nothing, obj, Nothing), Int32)
        Console.WriteLine("MyProp: {0}", v)
    End Sub
End Class

Commenti

Nota

Non è possibile usare InvokeMember per richiamare un metodo generico.

È possibile usare i flag di filtro seguenti BindingFlags per definire i membri da includere nella ricerca:

Specificare BindingFlags.Public per includere i membri pubblici nella ricerca.
Specificare BindingFlags.NonPublic di includere membri non pubblici (ovvero membri privati e protetti) nella ricerca.
Specificare BindingFlags.FlattenHierarchy per includere membri statici verso l'alto nella gerarchia.

Per modificare il funzionamento della ricerca, è possibile usare i flag di modificatore seguenti BindingFlags :

BindingFlags.IgnoreCase per ignorare il caso di name.
BindingFlags.DeclaredOnly per cercare solo i membri dichiarati in Type, non i membri semplicemente ereditati.

I flag di chiamata seguenti BindingFlags possono essere usati per indicare l'azione da eseguire 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.Instancee 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 sono soddisfatte entrambe le condizioni seguenti:

Il numero di parametri nella dichiarazione del metodo è uguale al numero di argomenti nella args matrice (a meno che non siano definiti argomenti predefiniti nel membro e BindingFlags.OptionalParamBinding sia specificato).
Il tipo di ogni argomento può essere convertito dal binder nel tipo del parametro .

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

Dopo aver selezionato il metodo, viene richiamato. L'accessibilità viene verificata a questo punto. La ricerca può controllare il set di metodi in cui viene eseguita la ricerca in base all'attributo di accessibilità associato al metodo . Il Binder.BindToMethod metodo della Binder classe è responsabile della selezione del metodo da richiamare. Il gestore di associazione predefinito seleziona la corrispondenza più specifica.

Le restrizioni di accesso vengono ignorate per il codice completamente attendibile; ovvero costruttori privati, metodi, campi e proprietà a cui è possibile accedere e richiamare System.Reflection ogni volta che il codice è completamente attendibile.

È possibile usare Type.InvokeMember per impostare un campo su un valore specifico specificando BindingFlags.SetField. Ad esempio, se si vuole impostare un campo di istanza pubblica denominato F nella classe C e F è un String, è possibile usare codice come:

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

Se F è un String[], è possibile usare codice come:

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

che inizializzerà il campo F in questa nuova matrice. È anche possibile usare Type.InvokeMember per impostare una posizione in una matrice specificando l'indice del valore e quindi il valore successivo usando codice come il seguente:

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

Verrà modificata la stringa "z" nella matrice che F contiene nella stringa "b".

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

Nota

A partire da .NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessione dei membri non pubblici è limitato al set di concessione del chiamante o a un subset. Vedere Considerazioni sulla sicurezza per Reflection.

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

Vedi anche

Si applica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Origine:: Type.cs

Origine:: Type.cs

Origine:: Type.cs

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

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);

public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);

public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Globalization.CultureInfo? culture);

public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Globalization.CultureInfo culture);

member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj

abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj

Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), culture As CultureInfo) As Object

Parametri

name: 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: BindingFlags

binder: Binder

-oppure-

target: Object

Oggetto su cui richiamare il membro specificato.

args: Object[]

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

culture: CultureInfo

Oggetto che rappresenta le impostazioni locali di globalizzazione da usare, che possono essere necessarie per conversioni specifiche delle impostazioni locali, ad esempio la conversione di un oggetto String numerico in Double.

-oppure-

Riferimento Null (Nothing in Visual Basic) per l'uso dell'oggetto CultureInfo del thread corrente.

Restituisce

Object

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Eccezioni

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-

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.

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.

Commenti

Anche se il binder predefinito non elabora CultureInfo (il culture parametro), è possibile usare la classe astratta System.Reflection.Binder per scrivere un binder personalizzato che elabora culture.

Nota

Non è possibile usare per richiamare InvokeMember un metodo generico.

I flag di filtro seguenti BindingFlags possono essere usati per definire i membri da includere nella ricerca:

Specificare BindingFlags.Public per includere membri pubblici nella ricerca.
Specificare BindingFlags.NonPublic per includere membri non pubblici, ovvero membri privati, interni e protetti, nella ricerca.
Specificare BindingFlags.FlattenHierarchy per includere membri statici fino alla gerarchia.

I flag di modifica seguenti BindingFlags possono essere usati per modificare il funzionamento della ricerca:

BindingFlags.IgnoreCase per ignorare il caso di name.
BindingFlags.DeclaredOnly per cercare solo i membri dichiarati in Type, non membri semplicemente ereditati.

I flag di chiamata seguenti BindingFlags possono essere usati per indicare l'azione da eseguire 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 viene specificato da se stesso, BindingFlags.Public, BindingFlags.Instancee 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.

Se entrambe le condizioni seguenti sono vere, verrà richiamato un metodo:

Il numero di parametri nella dichiarazione del metodo equivale al numero di argomenti nella args matrice (a meno che non vengano definiti argomenti predefiniti nel membro e BindingFlags.OptionalParamBinding specificati).
Il tipo di ogni argomento può essere convertito dal binder al tipo del parametro.

Il binder troverà tutti i metodi corrispondenti. Questi metodi vengono trovati in base al tipo di associazione richiesta (BindingFlags valori InvokeMethod, GetPropertye 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. L'accessibilità viene verificata a quel punto. La ricerca può controllare quale set di metodi vengono ricercati in base all'attributo di accessibilità associato al metodo . Il Binder.BindToMethod metodo della classe è responsabile della selezione del Binder metodo da richiamare. Il binder predefinito seleziona la corrispondenza più specifica.

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

È possibile usare Type.InvokeMember per impostare un campo su un determinato valore specificando BindingFlags.SetField. Ad esempio, se si vuole impostare un campo di istanza pubblica denominato F nella classe C e F è String possibile usare il codice, ad esempio:

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

Se F è un String[]oggetto , è possibile usare il codice, ad esempio:

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

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

Verrà modificata la stringa "z" nella matrice contenente F nella stringa "b".

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

Nota

A partire da .NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei membri non pubblici è limitato al set di concessioni del chiamante o a un subset. Vedere Considerazioni sulla sicurezza per la reflection.

Per usare questa funzionalità, l'applicazione deve avere come destinazione .NET Framework 3.5 o versione successiva.

Vedi anche

Si applica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Origine:: Type.cs

Origine:: Type.cs

Origine:: Type.cs

Quando ne viene eseguito l'override in una classe derivata, richiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti, i modificatori e le impostazioni cultura specificati.

public:
 abstract 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 abstract 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 abstract 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 MustOverride 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

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: BindingFlags

binder: Binder

-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: Object

Oggetto su cui richiamare il membro specificato.

args: Object[]

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

modifiers: ParameterModifier[]

Matrice di oggetti ParameterModifier che rappresentano gli attributi associati all'elemento corrispondente nella matrice args. Gli attributi associati di un parametro sono archiviati nella firma digitale del membro.

Il binder predefinito elabora questo parametro solo quando si chiama un componente COM.

culture: CultureInfo

Oggetto CultureInfo che rappresenta le impostazioni locali da usare, che possono essere necessarie per conversioni specifiche delle impostazioni locali, ad esempio la conversione di un valore numerico da String a Double.

-oppure-

Riferimento Null (Nothing in Visual Basic) per l'uso dell'oggetto CultureInfo del thread corrente.

namedParameters: String[]

Matrice contenente i nomi dei parametri a cui sono passati i valori nella matrice args.

Restituisce

Object

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Eccezioni

ArgumentNullException

invokeAttr non contiene CreateInstance e name è null.

ArgumentException

args e modifiers non hanno la stessa lunghezza.

-oppure-

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-

La matrice di parametri denominata è più grande della matrice di argomenti.

-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-

Non è possibile trovare membri con i nomi di argomento forniti in namedParameters.

-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.

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.

Commenti

InvokeMember chiama un membro del costruttore o un membro del metodo, ottiene o imposta un membro della proprietà, ottiene o imposta un membro del campo dati oppure ottiene o imposta un elemento di un membro di matrice.

Nota

Non è possibile usare InvokeMember per richiamare un metodo generico.

Anche se il binder predefinito non elabora ParameterModifier o CultureInfo (i parametri e culture ), è possibile usare la classe astratta System.Reflection.Binder per scrivere un binder personalizzato che esegue l'elaborazione modifiersmodifiers e culture. ParameterModifier viene usato solo quando si chiama tramite l'interoperabilità COM e vengono gestiti solo i parametri passati per riferimento.

Tutti i parametri nella matrice namedParameters ottengono il valore nell'elemento corrispondente della matrice args. Se la lunghezza di args è superiore a quella di namedParameters, i valori degli argomenti rimanenti vengono passati in ordine.

La namedParameters matrice può essere usata per modificare l'ordine degli argomenti in una matrice di input. Ad esempio, dato il metodo M(string a, int b) (M(ByVal a As String, ByVal b As Integer) in Visual Basic) e la matrice { 42, "x" }di input , la matrice di input può essere passata invariata a args se la matrice { "b", "a" } viene fornita per namedParameters.

È possibile usare i flag di filtro seguenti BindingFlags per definire i membri da includere nella ricerca:

Specificare BindingFlags.Public per includere i membri pubblici nella ricerca.
Specificare BindingFlags.NonPublic di includere membri non pubblici (ovvero membri privati, interni e protetti) nella ricerca.
Specificare BindingFlags.FlattenHierarchy per includere membri statici verso l'alto nella gerarchia.

Per modificare il funzionamento della ricerca, è possibile usare i flag di modificatore seguenti BindingFlags :

BindingFlags.IgnoreCase per ignorare il caso di name.
BindingFlags.DeclaredOnly per cercare solo i membri dichiarati in Type, non i membri semplicemente ereditati.

I flag di chiamata seguenti BindingFlags possono essere usati per indicare l'azione da eseguire 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.Instancee 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 sono soddisfatte entrambe le condizioni seguenti:

Il numero di parametri nella dichiarazione del metodo è uguale al numero di argomenti nella args matrice (a meno che non siano definiti argomenti predefiniti nel membro e BindingFlags.OptionalParamBinding sia specificato).
Il tipo di ogni argomento può essere convertito dal binder nel tipo del parametro .

InvokeMember può essere usato per richiamare metodi con parametri con valori predefiniti. Per eseguire l'associazione a questi metodi, è necessario BindingFlags.OptionalParamBinding specificare Reflection. Per un parametro con un valore predefinito, è possibile specificare un valore diverso oppure specificare Missing.Value per usare il valore predefinito.

Si consideri ad esempio un metodo come MyMethod(int x, float y = 2.0). Per richiamare questo metodo con solo il primo argomento come MyMethod(4), passare uno dei flag di associazione precedenti e passare due argomenti, ovvero 4 per il primo argomento e Missing.Value per il secondo argomento. A meno che non si usi Missing.Value, non è possibile omettere parametri facoltativi con il Invoke metodo . Se necessario, usare InvokeMember invece .

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

Se F è un String[], è possibile usare codice come:

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

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

Verrà modificata la stringa "z" nella matrice che F contiene nella stringa "b".

Nota

A partire da .NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a membri non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei membri non pubblici è limitato al set di concessioni del chiamante o a un subset. Vedere Considerazioni sulla sicurezza per la reflection.

Per usare questa funzionalità, l'applicazione deve avere come destinazione .NET Framework 3.5 o versione successiva.

Vedi anche

Si applica a

Condividi tramite

Type.InvokeMember Metodo

Definizione

Overload

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Parametri

Restituisce

Implementazioni

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Parametri

Restituisce

Implementazioni

Eccezioni

Commenti

Vedi anche

Si applica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Parametri

Restituisce

Implementazioni

Eccezioni

Commenti

Vedi anche

Si applica a

Risorse aggiuntive