Type.InvokeMember Méthode

Source:

Type.cs

Source:

Type.cs

Source:

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

Paramètres

Retours

Objet représentant la valeur de retour du membre appelé.

Implémente

Exceptions

Exemples

L’exemple suivant utilise InvokeMember pour accéder aux membres d’un type.

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

Remarques

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les membres à inclure dans la recherche :

• Spécifiez BindingFlags.Public pour inclure des membres publics dans la recherche.

• Spécifiez BindingFlags.NonPublic pour inclure des membres non publics (c’est-à-dire des membres privés et protégés) dans la recherche.

• Spécifiez BindingFlags.FlattenHierarchy pour inclure des membres statiques dans la hiérarchie.

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

• BindingFlags.IgnoreCase pour ignorer le cas de name.

• BindingFlags.DeclaredOnly pour rechercher uniquement les membres déclarés sur , Typeet non les membres qui ont simplement été hérités.

Les indicateurs d’appel suivants BindingFlags peuvent être utilisés pour indiquer l’action à entreprendre avec le membre :

• CreateInstance pour appeler un constructeur. name est ignoré. Non valide avec d’autres indicateurs d’appel.

• InvokeMethod pour appeler une méthode, mais pas un constructeur ou un initialiseur de type. Non valide avec SetField ou SetProperty. Si InvokeMethod est spécifié par lui-même, BindingFlags.Public, BindingFlags.Instanceet BindingFlags.Static sont automatiquement inclus.

• GetField pour obtenir la valeur d’un champ. Non valide avec SetField.

• SetField pour définir la valeur d’un champ. Non valide avec GetField.

• GetProperty pour obtenir une propriété. Non valide avec SetProperty.

• SetProperty pour définir une propriété. Non valide avec GetProperty.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Une méthode est appelée si les deux conditions suivantes sont remplies :

• Le nombre de paramètres dans la déclaration de méthode est égal au nombre d’arguments dans le args tableau (sauf si les arguments par défaut sont définis sur le membre et BindingFlags.OptionalParamBinding spécifiés).

• Le type de chaque argument peut être converti par le classeur en type du paramètre.

Le classeur recherche toutes les méthodes correspondantes. Ces méthodes sont trouvées en fonction du type de liaison demandé (BindingFlags valeurs InvokeMethod, GetProperty, etc.). L’ensemble de méthodes est filtré par le nom, le nombre d’arguments et un ensemble de modificateurs de recherche définis dans le classeur.

Une fois la méthode sélectionnée, elle est appelée. L’accessibilité est vérifiée à ce stade. La recherche peut contrôler l’ensemble de méthodes recherché en fonction de l’attribut d’accessibilité associé à la méthode. La Binder.BindToMethod méthode de la Binder classe est chargée de sélectionner la méthode à appeler. Le classeur par défaut sélectionne la correspondance la plus spécifique.

Les restrictions d’accès sont ignorées pour le code entièrement approuvé ; Autrement dit, les constructeurs privés, les méthodes, les champs et les propriétés sont accessibles et appelés chaque System.Reflection fois que le code est entièrement approuvé.

Vous pouvez utiliser Type.InvokeMember pour définir un champ sur une valeur particulière en spécifiant BindingFlags.SetField. Par exemple, si vous souhaitez définir un champ de instance public nommé F sur la classe C et que F est un , vous pouvez utiliser du Stringcode tel que :

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

Si F est un , vous pouvez utiliser du String[]code tel que :

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

qui initialisera le champ F dans ce nouveau tableau. Vous pouvez également utiliser Type.InvokeMember pour définir une position dans un tableau en fournissant l’index de la valeur, puis la valeur suivante à l’aide de code tel que le suivant :

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

Cela remplace la chaîne « z » dans le tableau que F contient en chaîne « b ».

Lorsque vous appelez un IDispatch membre, vous pouvez spécifier le DispID au lieu du nom du membre, en utilisant le format de chaîne « [DispID=##] ». Par exemple, si le DispID de MyComMethod est 3, vous pouvez spécifier la chaîne « [DispID=3] » au lieu de « MyComMethod ». L’appel d’un membre par DispID est plus rapide que la recherche du membre par nom. Dans les scénarios d’agrégation complexes, le DispID est parfois le seul moyen d’appeler le membre souhaité.

Voir aussi

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

Source:

Type.cs

Source:

Type.cs

Source:

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

Paramètres

Retours

Objet représentant la valeur de retour du membre appelé.

Implémente

Exceptions

Remarques

Bien que le classeur par défaut ne traite CultureInfo pas (le culture paramètre), vous pouvez utiliser la classe abstraite System.Reflection.Binder pour écrire un classeur personnalisé qui traite culture.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les membres à inclure dans la recherche :

• Spécifiez BindingFlags.Public pour inclure des membres publics dans la recherche.

• Spécifiez BindingFlags.NonPublic pour inclure des membres non publics (c’est-à-dire des membres privés, internes et protégés) dans la recherche.

• Spécifiez BindingFlags.FlattenHierarchy pour inclure des membres statiques dans la hiérarchie.

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

• BindingFlags.IgnoreCase pour ignorer le cas de name.

• BindingFlags.DeclaredOnly pour rechercher uniquement les membres déclarés sur , Typeet non les membres qui ont simplement été hérités.

Les indicateurs d’appel suivants BindingFlags peuvent être utilisés pour indiquer l’action à entreprendre avec le membre :

• CreateInstance pour appeler un constructeur. name est ignoré. Non valide avec d’autres indicateurs d’appel.

• InvokeMethod pour appeler une méthode, mais pas un constructeur ou un initialiseur de type. Non valide avec SetField ou SetProperty. Si InvokeMethod est spécifié par lui-même, BindingFlags.Public, BindingFlags.Instanceet BindingFlags.Static sont automatiquement inclus.

• GetField pour obtenir la valeur d’un champ. Non valide avec SetField.

• SetField pour définir la valeur d’un champ. Non valide avec GetField.

• GetProperty pour obtenir une propriété. Non valide avec SetProperty.

• SetProperty pour définir une propriété. Non valide avec GetProperty.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Une méthode est appelée si les deux conditions suivantes sont remplies :

• Le nombre de paramètres dans la déclaration de méthode est égal au nombre d’arguments dans le args tableau (sauf si les arguments par défaut sont définis sur le membre et BindingFlags.OptionalParamBinding spécifiés).

• Le type de chaque argument peut être converti par le classeur en type du paramètre.

Le classeur recherche toutes les méthodes correspondantes. Ces méthodes sont trouvées en fonction du type de liaison demandé (BindingFlags valeurs InvokeMethod, GetProperty, etc.). L’ensemble de méthodes est filtré par le nom, le nombre d’arguments et un ensemble de modificateurs de recherche définis dans le classeur.

Une fois la méthode sélectionnée, elle est appelée. L’accessibilité est vérifiée à ce stade. La recherche peut contrôler l’ensemble de méthodes recherché en fonction de l’attribut d’accessibilité associé à la méthode. La Binder.BindToMethod méthode de la Binder classe est chargée de sélectionner la méthode à appeler. Le classeur par défaut sélectionne la correspondance la plus spécifique.

Les restrictions d’accès sont ignorées pour le code entièrement approuvé ; Autrement dit, les constructeurs privés, les méthodes, les champs et les propriétés sont accessibles et appelés via Reflection chaque fois que le code est entièrement approuvé.

Vous pouvez utiliser Type.InvokeMember pour définir un champ sur une valeur particulière en spécifiant BindingFlags.SetField. Par exemple, si vous souhaitez définir un champ de instance public nommé F sur la classe C et que F est un, vous pouvez utiliser du String code tel que :

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

Si F est un , vous pouvez utiliser du String[]code tel que :

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

qui initialisera le champ F dans ce nouveau tableau. Vous pouvez également utiliser Type.InvokeMember pour définir une position dans un tableau en fournissant l’index de la valeur, puis la valeur suivante à l’aide de code tel que le suivant :

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

Cela remplace la chaîne « z » dans le tableau que F contient en chaîne « b ».

Lorsque vous appelez un IDispatch membre, vous pouvez spécifier le DispID au lieu du nom du membre, en utilisant le format de chaîne « [DispID=##] ». Par exemple, si le DispID de MyComMethod est 3, vous pouvez spécifier la chaîne « [DispID=3] » au lieu de « MyComMethod ». L’appel d’un membre par DispID est plus rapide que la recherche du membre par nom. Dans les scénarios d’agrégation complexes, le DispID est parfois le seul moyen d’appeler le membre souhaité.

Voir aussi

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

Source:

Type.cs

Source:

Type.cs

Source:

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

Paramètres

Retours

Objet représentant la valeur de retour du membre appelé.

Implémente

Exceptions

Remarques

InvokeMember appelle un membre de constructeur ou un membre de méthode, obtient ou définit un membre de propriété, obtient ou définit un membre de champ de données, ou obtient ou définit un élément d’un membre de tableau.

Lorsque vous appelez un IDispatch membre, vous pouvez spécifier le DispID au lieu du nom du membre, en utilisant le format de chaîne « [DispID=##] ». Par exemple, si le DispID de MyComMethod est 3, vous pouvez spécifier la chaîne « [DispID=3] » au lieu de « MyComMethod ». L’appel d’un membre par DispID est plus rapide que la recherche du membre par son nom. Dans les scénarios d’agrégation complexes, dispID est parfois le seul moyen d’appeler le membre souhaité.

Bien que le classeur par défaut ne traite ParameterModifier pas ou CultureInfo (les modifiers paramètres et culture ), vous pouvez utiliser la classe abstraite System.Reflection.Binder pour écrire un classeur personnalisé qui traite modifiers et culture. ParameterModifier est utilisé uniquement lors de l’appel via COM Interop, et seuls les paramètres passés par référence sont gérés.

Chaque paramètre dans le tableau namedParameters obtient la valeur de l’élément correspondant dans le tableau args. Si la longueur de args est supérieure à la longueur de namedParameters, les valeurs d’argument restantes sont passées dans l’ordre.

Le namedParameters tableau peut être utilisé pour modifier l’ordre des arguments dans un tableau d’entrée. Par exemple, étant donné la méthode M(string a, int b) ( en Visual Basic) et le tableau { 42, "x" }d’entrée , le tableau d’entrée peut être passé inchangé à args si le tableau { "b", "a" } est fourni pour namedParametersM(ByVal a As String, ByVal b As Integer) .

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les membres à inclure dans la recherche :

• Spécifiez BindingFlags.Public pour inclure les membres publics dans la recherche.

• Spécifiez BindingFlags.NonPublic pour inclure des membres non publics (c’est-à-dire des membres privés, internes et protégés) dans la recherche.

• Spécifiez BindingFlags.FlattenHierarchy pour inclure les membres statiques dans la hiérarchie.

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

• BindingFlags.IgnoreCase pour ignorer le cas de name.

• BindingFlags.DeclaredOnly pour rechercher uniquement les membres déclarés sur le Type, et non les membres qui ont été simplement hérités.

Les indicateurs d’appel suivants BindingFlags peuvent être utilisés pour indiquer l’action à entreprendre avec le membre :

• CreateInstance pour appeler un constructeur. name est ignoré. Non valide avec d’autres indicateurs d’appel.

• InvokeMethod pour appeler une méthode, mais pas un constructeur ou un initialiseur de type. Non valide avec SetField ou SetProperty. Si InvokeMethod est spécifié par lui-même, BindingFlags.Public, BindingFlags.Instanceet BindingFlags.Static sont automatiquement inclus.

• GetField pour obtenir la valeur d’un champ. Non valide avec SetField.

• SetField pour définir la valeur d’un champ. Non valide avec GetField.

• GetProperty pour obtenir une propriété. Non valide avec SetProperty.

• SetProperty pour définir une propriété. Non valide avec GetProperty.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Une méthode est appelée si les deux conditions suivantes sont remplies :

• Le nombre de paramètres dans la déclaration de méthode est égal au nombre d’arguments dans le args tableau (sauf si les arguments par défaut sont définis sur le membre et BindingFlags.OptionalParamBinding sont spécifiés).

• Le type de chaque argument peut être converti par le classeur en type du paramètre .

Le binder trouvera toutes les méthodes correspondantes. Ces méthodes sont trouvées en fonction du type de liaison demandé (BindingFlags valeurs InvokeMethod, GetProperty, etc.). L’ensemble de méthodes est filtré par le nom, le nombre d’arguments et un ensemble de modificateurs de recherche définis dans le classeur.

Une fois la méthode sélectionnée, elle est appelée. L’accessibilité est vérifiée à ce stade. La recherche peut contrôler l’ensemble de méthodes recherché en fonction de l’attribut d’accessibilité associé à la méthode. La Binder.BindToMethod méthode de la Binder classe est chargée de sélectionner la méthode à appeler. Le classeur par défaut sélectionne la correspondance la plus spécifique.

InvokeMember peut être utilisé pour appeler des méthodes avec des paramètres qui ont des valeurs par défaut. Pour établir une liaison à ces méthodes, la réflexion doit BindingFlags.OptionalParamBinding être spécifiée. Pour un paramètre qui a une valeur par défaut, vous pouvez soit fournir une autre valeur, soit fournir Missing.Value pour utiliser la valeur par défaut.

Par exemple, considérez une méthode telle que MyMethod(int x, float y = 2.0). Pour appeler cette méthode avec uniquement le premier argument MyMethod(4), passez l’un des indicateurs de liaison ci-dessus et passez deux arguments, à savoir 4 pour le premier argument et Missing.Value pour le deuxième argument. Sauf si vous utilisez Missing.Value, vous ne pouvez pas omettre des paramètres facultatifs avec la Invoke méthode . Si vous devez le faire, utilisez InvokeMember à la place.

Les restrictions d’accès sont ignorées pour le code entièrement approuvé ; Autrement dit, les constructeurs privés, les méthodes, les champs et les propriétés sont accessibles et appelés chaque System.Reflection fois que le code est entièrement approuvé.

Vous pouvez utiliser Type.InvokeMember pour définir un champ sur une valeur particulière en spécifiant BindingFlags.SetField. Par exemple, si vous souhaitez définir un champ de instance public nommé F sur la classe C et que F est un , vous pouvez utiliser du Stringcode tel que :

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

Si F est un , vous pouvez utiliser du String[]code tel que :

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

qui initialisera le champ F dans ce nouveau tableau. Vous pouvez également utiliser Type.InvokeMember pour définir une position dans un tableau en fournissant l’index de la valeur, puis la valeur suivante à l’aide de code tel que le suivant :

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

Cela remplace la chaîne « z » dans le tableau que F contient en chaîne « b ».

Voir aussi

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