Type.InvokeMember, méthode (String, BindingFlags, Binder, Object, Object[])

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

Implémentations

Remarque
Vous ne pouvez pas utiliser InvokeMember pour appeler une méthode générique.

Les indicateurs de filtre BindingFlags suivants 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 les membres non publics (c'est-à-dire les membres privés et protégés) dans la recherche.

• Spécifiez BindingFlags.FlattenHierarchy pour inclure les membres statiques en haut de la hiérarchie.

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

• BindingFlags.IgnoreCase pour ignorer la casse de name.

• BindingFlags.DeclaredOnly pour limiter la recherche aux membres déclarés dans Type et exclure ceux qui ont été simplement hérités.

Les indicateurs d'appel BindingFlags suivants peuvent être utilisés pour désigner l'action à effectuer sur le membre :

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

• InvokeMethod pour appeler une méthode, mais pas un constructeur ni un initialiseur de type. Non valide avec SetField ou SetProperty. Si InvokeMethod est spécifié par lui-même, BindingFlags.Public, BindingFlags.Instance et BindingFlags.Static sont alors 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 System.Reflection.BindingFlags pour plus d'informations.

Une méthode est appelée si les conditions suivantes sont vérifiées :

• Le nombre de paramètres de la déclaration de méthode est égal au nombre d'arguments du tableau args (à moins que le membre ne possède des arguments définis par défaut) et que BindingFlags.OptionalParamBinding soit spécifié), et

• Le type de chaque argument peut être converti par le binder pour correspondre au type du paramètre.

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

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

Les restrictions d'accès sont ignorées pour le code d'un niveau de confiance suffisant ; autrement dit, il est possible d'accéder et de faire appel à des constructeurs, méthodes, champs et propriétés privés via System.Reflection dès lors que le code est d'un niveau de confiance suffisant.

Vous pouvez utiliser Type.InvokeMember pour affecter une valeur spécifique à un champ en spécifiant BindingFlags.SetField. Par exemple, si vous voulez définir un champ d'instance public nommé F sur la classe C, et si F est String, vous pouvez utiliser le code suivant :

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

Si F est String[], vous pouvez utiliser le code suivant :

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

ce qui initialisera le champ F à ce nouveau tableau. De plus, vous pouvez utiliser Type.InvokeMember pour définir une position dans un tableau en fournissant l'index de la valeur puis la valeur suivante, à l'aide du code suivant :

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

La chaîne "z" du tableau que F contient est remplacée par la chaîne "b".

Lorsque vous appelez un membre IDispatch, vous pouvez spécifier le DispID à la place du nom de membre à l'aide du format de chaîne "[DispID=##]". Par exemple, si le DispID de MyComMethod est 3, vous pouvez spécifier la chaîne "[DispID=3]" à la place de "MyComMethod". Il est plus rapide d'appeler un membre par DispID que de le rechercher par son nom. Dans des scénarios d'agrégation complexes, le DispID représente parfois la seule façon d'appeler le membre souhaité.

Remarque

À partir du .NET Framework version 2.0 Service Pack 1, cette méthode peut être utilisée pour accéder aux membres non publics si l'autorisation ReflectionPermission avec l'indicateur ReflectionPermissionFlag.RestrictedMemberAccess a été accordée à l'appelant et si le jeu d'autorisations des membres non publics est limité au jeu d'autorisations de l'appelant ou un sous-ensemble de ce jeu. (Consultez Considérations sur la sécurité de la réflexion.) Pour utiliser cette fonctionnalité, votre application doit cibler le .NET Framework version 3.5 ou une version ultérieure.

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

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

.NET Framework

.NET Framework Client Profile

• ReflectionPermission  

  pour accéder aux membres non publics lorsque le jeu d'autorisations des membres non publics est limité au jeu d'autorisations de l'appelant ou un sous-ensemble de ce jeu. Énumération associée : ReflectionPermissionFlag.RestrictedMemberAccess.

• ReflectionPermission  

  pour accéder aux membres non publics quel que soit leur jeu d'autorisations. Énumération associée : ReflectionPermissionFlag.MemberAccess.

• SecurityPermission  

  pour appeler un code non managé. Énumération associée : SecurityPermissionFlag.UnmanagedCode.

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Référence