IReflect.InvokeMember Méthode

  • Référence

Définition

Espace de noms:
System.Reflection
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Appelle un membre spécifié.

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

Nom du membre à rechercher.

invokeAttr
BindingFlags

Un des attributs d'appel BindingFlags. Le paramètre invokeAttr peut être un constructeur, une méthode, une propriété ou un champ. Un attribut d’appel approprié doit être spécifié. Il est possible d'appeler le membre par défaut d'une classe en passant une chaîne vide ("") en tant que nom du membre.

binder
Binder

Un des indicateurs binaires BindingFlags. Implémente Binder, contenant les propriétés associées à cette méthode.

target
Object

Objet sur lequel appeler le membre spécifié. Ce paramètre est ignoré pour les membres statiques.

args
Object[]

Tableau d'objets qui contient le nombre, l'ordre et le type des paramètres du membre à appeler. En l'absence de paramètres, ce tableau est vide.

modifiers
ParameterModifier[]

Tableau d'objets ParameterModifier. La longueur de ce tableau est égale à celle du paramètre args représentant les attributs d'argument du membre appelé dans les métadonnées. Un paramètre peut avoir les attributs suivants : pdIn, pdOut, pdRetval, pdOptional ou pdHasDefault. Ceux-ci représentent [In], [Out], [retval], [optional], et un paramètre par défaut, respectivement. Ils sont utilisés par divers services d'interopérabilité.

culture
CultureInfo

Instance de CultureInfo utilisée pour régir la contrainte des types. Par exemple, culture convertit une chaîne représentant 1 000 en une valeur Double, car 1 000 est représenté de différentes manières selon la culture. Si ce paramètre est null, le CultureInfo du thread en cours est utilisé.

namedParameters
String[]

Tableau de chaînes de paramètres.

Retours

Object

Membre spécifié.

Exceptions

ArgumentException

Plusieurs arguments sont spécifiés pour un champ set.

MissingFieldException

Le champ ou la propriété est introuvable.

MissingMethodException

La méthode est introuvable.

SecurityException

Un membre privé est appelé sans le ReflectionPermission nécessaire.

Exemples

L’exemple suivant obtient la valeur de la Now propriété.

#using <System.DLL>

using namespace System;
using namespace System::Reflection;

#define NULL 0
void main()
{
   Type^ tDate = Type::GetType( L"System.DateTime" );
   Object^ result = tDate->InvokeMember( L"Now", BindingFlags::GetProperty, nullptr, NULL, gcnew array<Object^>(0) );
   Console::WriteLine( result->ToString() );
}

using System;
using System.Reflection;

public class MainClass
{
    public static void Main(string[] args)
    {
        Type tDate = typeof(System.DateTime);
        Object result = tDate.InvokeMember("Now",
            BindingFlags.GetProperty, null, null, new Object[0]);
        Console.WriteLine(result.ToString());
    }
}

Imports System.Reflection

Public Class MainClass
    Public Overloads Shared Sub Main(ByVal args() As String)
        Dim tDate As Type = GetType(System.DateTime)
        Dim result As [Object] = tDate.InvokeMember("Now", _
            BindingFlags.GetProperty, Nothing, Nothing, New [Object](-1) {})
        Console.WriteLine(result.ToString())
    End Sub
End Class

Remarques

La méthode à appeler doit être accessible et fournir la correspondance la plus spécifique avec la liste d’arguments spécifiée, sous les contraintes des attributs de binder et d’appel spécifiés.

Une méthode est appelée si le nombre de paramètres dans la déclaration de méthode est égal au nombre d’arguments dans la liste d’arguments spécifiée, et que le type de chaque argument peut être converti par le classeur en type du paramètre.

Notes

Le tableau de modificateurs de paramètres transmis à la InvokeMember méthode doit contenir un modificateur de paramètre unique. Seul le premier modificateur de paramètre est pris en compte lors de la détermination de l’argument à transmettre par référence lorsqu’il est exposé à COM.

Le classeur trouve toutes les méthodes correspondantes, conformément au type de liaison demandé (BindingFlags.InvokeMethodGetProperties, 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 et l’accessibilité est vérifiée à ce stade. La recherche peut contrôler quel ensemble de méthodes est recherché en fonction de l’attribut d’accessibilité associé à la méthode. BindToMethod sélectionne 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 par réflexion chaque fois que le code est entièrement approuvé.

S’applique à

Voir aussi