Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

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

 

Date de publication : novembre 2016

Appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments spécifiée.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

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

Paramètres

name
Type: System.String

Chaîne contenant le nom du membre de constructeur, de méthode, de propriété ou de champ à appeler.

ou

Une chaîne vide ("") pour appeler le membre par défaut.

ou

Pour les membres IDispatch, chaîne représentant le DispID, par exemple "[DispID=3]".

invokeAttr
Type: System.Reflection.BindingFlags

Masque de bits constitué d'un ou de plusieurs BindingFlags spécifiant le mode d'exécution de la recherche. L'accès peut être fourni par l'un des BindingFlags, par exemple Public, NonPublic, Private, InvokeMethod, GetField, etc. Il n'est pas nécessaire de spécifier le type de recherche. Si le type de recherche est omis, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static sont utilisés.

binder
Type: System.Reflection.Binder

Objet qui définit un ensemble de propriétés et permet la liaison, ce qui peut impliquer la sélection d'une méthode surchargée, la contrainte de types d'arguments et l'appel d'un membre par la réflexion.

ou

Référence null (Nothing en Visual Basic) pour utiliser DefaultBinder. Notez que la définition explicite d'un objet Binder peut être nécessaire pour appeler correctement des surcharges de méthode avec des arguments variables.

target
Type: System.Object

Objet sur lequel appeler le membre spécifié.

args
Type: System.Object[]

Tableau contenant les arguments à passer au membre à appeler.

Valeur de retour

Type: System.Object

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

Exception Condition
ArgumentNullException

invokeAttr ne contient pas CreateInstance et name est null.

ArgumentException

invokeAttr n’est pas un attribut BindingFlags valide.

ou

invokeAttr ne contient pas l’un des indicateurs de liaison suivants : InvokeMethod, CreateInstance, GetField, SetField, GetProperty ou SetProperty.

ou

invokeAttr contient CreateInstance combiné avec InvokeMethod, GetField, SetField, GetProperty ou SetProperty.

ou

invokeAttr contient à la fois GetField et SetField.

ou

invokeAttr contient à la fois GetProperty et SetProperty.

ou

invokeAttr contient InvokeMethod combiné avec SetField ou SetProperty.

ou

invokeAttr contient SetField et args a plusieurs éléments.

ou

Cette méthode est appelée sur un objet COM et l’un des indicateurs de liaisons suivants n’a pas été passé : BindingFlags.InvokeMethod, BindingFlags.GetProperty, BindingFlags.SetProperty, BindingFlags.PutDispProperty ou BindingFlags.PutRefDispProperty.

ou

L’un des tableaux de paramètres nommés contient une chaîne qui est null.

MethodAccessException

Le membre spécifié est un initialiseur de classe.

MissingFieldException

Le champ ou la propriété est introuvable.

MissingMethodException

Aucune méthode ne peut être trouvée qui correspond aux arguments de args.

ou

L’objet Type actuel représente un type qui contient les paramètres de type ouverts, à savoir, ContainsGenericParameters retourne true.

TargetException

Le membre spécifié ne peut pas être appelé sur target.

AmbiguousMatchException

Plusieurs méthodes correspondent aux critères de liaison.

NotSupportedException

Le .NET Compact Framework ne prend pas en charge cette méthode.

InvalidOperationException

La méthode représentée par name a un ou plusieurs paramètres de type générique non spécifiés. Autrement dit, la propriété ContainsGenericParameters de la méthode retourne true.

System_CAPS_noteRemarque

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

Les éléments suivants BindingFlags les indicateurs de filtre 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 dans la hiérarchie.

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

  • BindingFlags.IgnoreCase pour ignorer la casse de name.

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

Les éléments suivants BindingFlags indicateurs d’appel peuvent être utilisés pour désigner l’action à effectuer sur 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.Instance, et 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.

Pour plus d'informations, voir System.Reflection.BindingFlags.

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 (à moins que les arguments par défaut sont définis sur le membre et BindingFlags.OptionalParamBinding est spécifié).

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

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

Une fois que la méthode est sélectionnée, elle est appelée. 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é à la méthode. Le Binder.BindToMethod Procédé de la Binder classe est chargée de sélectionner la méthode à appeler. Le binder par défaut sélectionne la correspondance la plus spécifique.

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

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

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

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

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. 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 en utilisant le code suivant :

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

Cette action modifie la chaîne « z » dans le tableau F conserve la chaîne « b ».

Lorsque vous appelez un IDispatch membre, vous pouvez spécifier le DispID au lieu 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] » au lieu de « MyComMethod ». Appeler un membre par DispID est plus rapide que Rechercher par nom. Dans les scénarios d’agrégation complexes, le DispID est parfois la seule façon d’appeler le membre souhaité.

System_CAPS_noteRemarque

Compter les .NET Framework 2.0 Service Pack 1, cette méthode peut être utilisée pour accéder aux membres non publics si l’appelant a été accordé ReflectionPermission avec la ReflectionPermissionFlag.RestrictedMemberAccess indicateur et si le jeu d’autorisations des membres non publics est limité à l’appelant de l’accorder l’ensemble ou un sous-ensemble de ce. (Consultez Considérations sur la sécurité de la réflexion.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5 ou 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);
    }
}

ReflectionPermission

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

ReflectionPermission

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

SecurityPermission

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

.NET Framework
Disponible depuis 1.1
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Retour au début
Afficher: