Type.InvokeMember Metodo

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

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

Restituisce

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

Eccezioni

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

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

Vedi anche

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

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

Restituisce

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

Eccezioni

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.

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

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 il codice, ad esempio quanto segue:

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.

Vedi anche

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Origine:

Type.cs

Origine:

Type.cs

Origine:

Type.cs

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

Restituisce

Oggetto che rappresenta il valore restituito di un membro richiamato.

Implementazioni

Eccezioni

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.

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.

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 .

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.

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 .

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

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"}, null, null, null);

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

Vedi anche

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission