InvokeMember Methode (String, BindingFlags, Binder, Object, Object[])
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Type.InvokeMember-Methode (String, BindingFlags, Binder, Object, Object[])

 

Ruft den angegebenen Member auf, der den angegebenen Bindungseinschränkungen und der angegebenen Argumentliste entspricht.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parameter

name

Die Zeichenfolge, die den Namen des Konstruktors, der Methode, der Eigenschaft oder des Feldmembers enthält, der bzw. die aufgerufen werden soll.

- oder -

Eine leere Zeichenfolge ("") zum Aufrufen des Standardmembers.

- oder -

Für IDispatch-Member eine Zeichenfolge, die die DispID darstellt, z. B. "[DispID=3]".

invokeAttr

Eine Bitmaske aus einem oder mehreren BindingFlags, die angeben, wie die Suche durchgeführt wird.Der Zugriff kann aus einem der BindingFlags wie Public, NonPublic, Private, InvokeMethod, GetField usw. bestehen.Die Art der Suche muss nicht angegeben werden.Wenn die Art der Suche ausgelassen wird, gilt BindingFlags.Public. | BindingFlags.Instance | BindingFlags.Static werden verwendet.

binder

Ein Objekt, das eine Gruppe von Eigenschaften definiert und eine Bindung ermöglicht. Dazu kann die Auswahl einer überladenen Methode, die Umwandlung von Argumenttypen und der Aufruf eines Members durch Reflektion gehören.

- oder -

Ein Nullverweis (Nothing in Visual Basic), wenn DefaultBinder verwendet werden soll.Beachten Sie, dass möglicherweise ein Binder-Objekt explizit definiert werden muss, um erfolgreich Methodenüberladungen mit Variablenargumenten aufrufen zu können.

target

Das Objekt, für das der angegebene Member aufgerufen werden soll.

args

Ein Array mit den Argumenten, die dem aufzurufenden Member übergeben werden sollen.

Rückgabewert

Type: System.Object

Ein Objekt, das den Rückgabewert des aufgerufenen Members darstellt.

Exception Condition
ArgumentNullException

invokeAttr enthält keine CreateInstance und name ist null.

ArgumentException

invokeAttr ist kein gültiger BindingFlags Attribut.

- oder -

invokeAttr enthält nicht eines der folgenden Bindungsflags: InvokeMethod, CreateInstance, GetField, SetField, GetProperty, oder SetProperty.

- oder -

invokeAttr enthält CreateInstance zusammen mit InvokeMethod, GetField, SetField, GetProperty, oder SetProperty.

- oder -

invokeAttr enthält GetField und SetField.

- oder -

invokeAttr enthält GetProperty und SetProperty.

- oder -

invokeAttr enthält InvokeMethod zusammen mit SetField oder SetProperty.

- oder -

invokeAttr enthält SetField und args verfügt über mehr als ein Element.

- oder -

Diese Methode wird für ein COM-Objekt aufgerufen und eine der folgenden Bindungsflags wurde nicht übergeben: BindingFlags.InvokeMethod, BindingFlags.GetProperty, BindingFlags.SetProperty, BindingFlags.PutDispProperty, oder BindingFlags.PutRefDispProperty.

- oder -

Eines der angegebenen Parameterarrays enthält eine Zeichenfolge, die null.

MethodAccessException

Das angegebene Element ist eine Klasseninitialisierung.

MissingFieldException

Das Feld oder die Eigenschaft wurde nicht gefunden.

MissingMethodException

Keine Methode befinden, entspricht die Argumente in args.

- oder -

Die aktuelle Type Objekt darstellt, einen Typ, der offene Typparameter, das heißt enthält, ContainsGenericParameters gibt true.

TargetException

Das angegebene Element kann nicht aufgerufen werden, auf target.

AmbiguousMatchException

Mehr als eine Methode entspricht den Bindungskriterien entspricht.

NotSupportedException

Diese Methode wird von .NET Compact Framework derzeit nicht unterstützt.

InvalidOperationException

Die dargestellte Methode name verfügt über eine oder mehrere nicht angegebene generische Typparameter.Das heißt, den der Methode ContainsGenericParameters gibt true.

System_CAPS_noteHinweis

Sie können keine InvokeMember eine generische Methode aufzurufen.

Die folgenden BindingFlags Filterflags kann festgelegt werden, welche Member in die Suche einbezogen werden:

  • Geben Sie BindingFlags.Public auf öffentliche Member in die Suche einbeziehen.

  • Geben Sie BindingFlags.NonPublic nicht öffentliche Member (d. h. private und geschützte Member) in die Suche einbezogen.

  • Geben Sie BindingFlags.FlattenHierarchy um statische Member aus der Hierarchie einzuschließen.

Die folgenden BindingFlags Modifiziererflags können verwendet werden, um die Funktionsweise der Suche ändern:

  • BindingFlags.IgnoreCase die Groß-/Kleinschreibung ignorieren name.

  • BindingFlags.DeclaredOnly Suchen von deklarierten Membern der Type, nicht die Elemente, die nur geerbt wurden.

Die folgenden BindingFlags Aufrufflags können dazu verwendet werden, welche Aktion für den Member durchgeführt werden soll:

  • CreateInstance zum Aufrufen eines Konstruktors. name wird ignoriert.Ungültig, wenn es mit anderen Aufrufflags verwendet wird.

  • InvokeMethod Um eine Methode, aber nicht auf einen Konstruktor oder eine Typeninitialisierung aufzurufen.Ungültig mit SetField oder SetProperty.Wenn InvokeMethod angegeben wird, BindingFlags.Public, BindingFlags.Instance, und BindingFlags.Static werden automatisch eingeschlossen.

  • GetField um den Wert eines Felds.Ungültig mit SetField.

  • SetField um den Wert eines Felds festzulegen.Ungültig mit GetField.

  • GetProperty zum Abrufen einer Eigenschaft.Ungültig mit SetProperty.

  • SetProperty zum Festlegen einer Eigenschaft.Ungültig mit GetProperty.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Eine Methode wird aufgerufen, wenn die beiden folgenden Bedingungen erfüllt sind:

  • Die Anzahl der Parameter in der Methodendeklaration entspricht der Anzahl der Argumente in der args Array (es sei denn, Sie Standardargumente für den Member definiert sind und BindingFlags.OptionalParamBinding angegeben ist).

  • Der Typ jedes Arguments kann vom Binder in den Typ des Parameters konvertiert werden.

Der Binder findet alle übereinstimmenden Methoden.Diese Methoden werden entsprechend dem angeforderten Bindungstyp gefunden (BindingFlags Werte InvokeMethod, GetProperty, usw.).Der Satz von Methoden wird durch den Namen, die Anzahl von Argumenten und einen Satz von Search-Modifizierer in der Binder definierten gefiltert.

Nachdem die Methode ausgewählt ist, wird diese aufgerufen.Barrierefreiheit ist an dieser Stelle überprüft.Die Suche kann steuern, welche Gruppe von Methoden durchsucht anhand der Methode zugeordneten Zugriffsattributs.Die Binder.BindToMethod Methode der Binder Klasse ist verantwortlich für die Auswahl der aufzurufenden Methode.Der Standardbinder wählt die beste Übereinstimmung.

Zugriffsbeschränkungen werden bei vollständig vertrauenswürdigem Code ignoriert. Das heißt, private Konstruktoren, Methoden, Felder und Eigenschaften werden und können durch aufgerufen System.Reflection jedes Mal, wenn der Code voll vertrauenswürdig ist.

Sie können Type.InvokeMember für einen bestimmten Wert ein Felds festzulegen, durch Angabe BindingFlags.SetField.Ist z. B. Wenn Sie eine öffentliche Instanzenfeld F auf Klasse C und F festlegen möchten eine String, Sie können z. B. Code verwenden:

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

Wenn F ist eine String[], Sie können z. B. Code verwenden:

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

die wird das Feld F für dieses neue Array initialisiert.Sie können auch Type.InvokeMember zu eine Position in einem Array festlegen, indem der Index des Werts und anschließend den nächsten Wert mithilfe von Code wie den folgenden:

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

Dadurch wird die Zeichenfolge "Z" im Array geändert, die auf die Zeichenfolge "b" F enthält.

Aufgerufen, wenn ein IDispatch Element, können Sie die DispID statt dem Membernamen das Zeichenfolgenformat mithilfe angeben "[DispID = ##]".Zum Beispiel wenn die DispID von MyComMethod 3 ist, können Sie die Zeichenfolge angeben "[DispID = 3]" statt "MyComMethod".Der Aufruf eines Members über die DispID ist schneller als die Suche nach dem Namen des Members.In Szenarios mit komplexer Aggregierung ist die DispID manchmal die einzige Möglichkeit, den gewünschten Member aufzurufen.

System_CAPS_noteHinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Member zuzugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit dem ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und der Berechtigungssatz der nicht öffentlichen Member an des Aufrufers beschränkt ist Set oder eine Teilmenge davon zu gewähren.(Siehe Sicherheitsüberlegungen für die Reflektion.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5 oder höher ausgelegt sein.

Im folgenden Beispiel wird InvokeMember den Zugriff auf Member eines Typs.

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: ReflectionPermissionFlag.RestrictedMemberAccess

ReflectionPermission

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

SecurityPermission

to call unmanaged code.Associated enumeration: SecurityPermissionFlag.UnmanagedCode

.NET Framework
Verfügbar seit 1.1
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Zurück zum Anfang
Anzeigen:
© 2016 Microsoft