Type.InvokeMember Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Appelle un membre spécifique du Type actuel.

Surcharges

InvokeMember(String, BindingFlags, Binder, Object, Object[])	Appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments spécifiée.
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Appelle le membre spécifié, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments et à la culture spécifiées.
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	En cas de substitution dans une classe dérivée, appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments, aux modificateurs et à la culture spécifiés.

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

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

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

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

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

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée 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: 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: Object

Objet sur lequel appeler le membre spécifié.

args: Object[]

Tableau contenant les arguments à passer au membre à appeler.

Retours

Object

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

Implémente

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

Exceptions

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.

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

Notes

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

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

Notes

À compter du .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 reçu ReflectionPermission l’indicateur ReflectionPermissionFlag.RestrictedMemberAccess et si l’ensemble d’octrois des membres non publics est limité à l’ensemble d’octrois de l’appelant ou à un sous-ensemble de celui-ci. (Consultez Considérations relatives à la sécurité pour la réflexion.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5 ou version ultérieure.

Voir aussi

S’applique à

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

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

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

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

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

binder: Binder

- ou -

target: Object

Objet sur lequel appeler le membre spécifié.

args: Object[]

Tableau contenant les arguments à passer au membre à appeler.

culture: CultureInfo

Objet représentant le paramètre régional de globalisation à utiliser si nécessaire, notamment pour les conversions spécifiques aux paramètres régionaux telles que la conversion d'un type numérique String en type Double.

- ou -

Référence null (Nothing en Visual Basic) pour utiliser le CultureInfo du thread actuel.

Retours

Object

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

Implémente

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

Exceptions

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 -

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.

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.

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.

Notes

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

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.

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

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

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

Notes

À compter de .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 reçu ReflectionPermission l’indicateur ReflectionPermissionFlag.RestrictedMemberAccess et si le jeu d’octrois des membres non publics est limité à l’ensemble d’octrois de l’appelant ou à un sous-ensemble de celui-ci. (Consultez Considérations relatives à la sécurité pour la réflexion.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5 ou version ultérieure.

Voir aussi

S’applique à

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

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

En cas de substitution dans une classe dérivée, appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments, aux modificateurs et à la culture spécifiés.

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

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

binder: Binder

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

Objet sur lequel appeler le membre spécifié.

args: Object[]

Tableau contenant les arguments à passer au membre à appeler.

modifiers: ParameterModifier[]

Tableau d'objets ParameterModifier représentant les attributs associés à l'élément correspondant dans le tableau args. Les attributs associés d'un paramètre sont stockés dans la signature du membre.

Le binder par défaut traite ce paramètre uniquement au moment de l'appel d'un composant COM.

culture: CultureInfo

Objet CultureInfo représentant le paramètre régional de globalisation à utiliser si nécessaire, notamment pour les conversions spécifiques aux paramètres régionaux comme la conversion d'un type numérique String en type Double.

- ou -

Référence null (Nothing en Visual Basic) pour utiliser le CultureInfo du thread actuel.

namedParameters: String[]

Tableau contenant les noms des paramètres auxquels les valeurs du tableau args sont passées.

Retours

Object

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

Implémente

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

Exceptions

ArgumentNullException

invokeAttr ne contient pas CreateInstance et name est null.

ArgumentException

args et modifiers n’ont pas la même longueur.

- ou -

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 -

Le tableau de paramètres nommé est supérieur à un tableau d’arguments.

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

Aucun membre ne peut être trouvé avec les noms des arguments fournis dans namedParameters.

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

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.

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.

Notes

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

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.

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.

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

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

Notes

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5 ou version ultérieure.

Voir aussi

S’applique à

Partage via

Type.InvokeMember Méthode

Définition

Surcharges

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

Paramètres

Retours

Implémente

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

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

Paramètres

Retours

Implémente

Exceptions

Remarques

Voir aussi

S’applique à

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

Paramètres

Retours

Implémente

Exceptions

Remarques

Voir aussi

S’applique à

Ressources supplémentaires