BindingFlags Enumeration

Definition

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Gibt Flags an, die die Bindung steuern und die Art bestimmen, wie die Reflektion die Suche nach Membern und Typen durchführt.

Diese Enumeration unterstützt eine bitweise Kombination ihrer Memberwerte.

C#

[System.Flags]
public enum BindingFlags

Vererbung

Object

ValueType

Enum

BindingFlags

Attribute

FlagsAttribute

Felder

Name	Wert	Beschreibung
CreateInstance	512	Gibt an, dass die Reflektion eine Instanz des angegebenen Typs erstellen soll. Ruft den Konstruktor auf, der mit den angegebenen Argumenten übereinstimmt. Der angegebene Membername wird ignoriert. Wenn die Art der Suche nicht angegeben ist, wird „(Instance | Public)“ angewendet. Es ist nicht möglich, einen Typeninitialisierer aufzurufen. Dieses Flag wird an eine InvokeMember-Methode übergeben, um einen Konstruktor aufzurufen.
DeclaredOnly	2	Gibt an, dass nur Member, die auf der Ebene der Hierarchie des angegebenen Typs deklariert wurden, berücksichtigt werden sollen. Geerbte Member werden nicht berücksichtigt.
Default	0	Gibt an, dass keine Bindungsflags definiert sind.
DoNotWrapExceptions	33554432
ExactBinding	65536	Gibt an, dass die Typen der angegebenen Argumente genau mit den Typen der entsprechenden formalen Parameter übereinstimmen müssen. Die Reflektion löst eine Ausnahme aus, wenn der Aufrufer ein Binder-Objekt liefert, das ungleich Null ist, da dies impliziert, dass der Aufrufer BindToXXX-Implementierungen bereitstellt, die die entsprechende Methode aufnehmen. Die Standardbindung ignoriert dieses Flag, während benutzerdefinierte Bindungen die Semantik dieses Flags implementieren können.
FlattenHierarchy	64	Gibt an, dass öffentliche und geschützte statische Member in der nach oben gerichteten Hierarchie zurückgegeben werden sollen. Private statische Member in geerbten Klassen werden nicht zurückgegeben. Statische Member enthalten Felder, Methoden, Ereignisse und Eigenschaften. Geschachtelte Typen werden nicht zurückgegeben.
GetField	1024	Gibt an, dass der Wert des angegebenen Felds zurückgegeben werden soll. Dieses Flag wird an eine InvokeMember-Methode übergeben, um einen Feldwert abzurufen.
GetProperty	4096	Gibt an, dass der Wert der angegebenen Eigenschaft zurückgegeben werden soll. Dieses Flag wird an eine InvokeMember-Methode übergeben, um einen Getter für eine Eigenschaft aufzurufen.
IgnoreCase	1	Gibt an, dass die Groß-/Kleinschreibung für den Membernamen beim Binden nicht berücksichtigt werden soll.
IgnoreReturn	16777216	Dieses wird in COM-Interop zur Angabe verwendet, dass der Rückgabewert des Members ignoriert werden kann.
Instance	4	Gibt an, dass Instanzmember in die Suche einbezogen werden.
InvokeMethod	256	Gibt an, dass eine Methode aufgerufen werden muss. Dies darf kein Konstruktor oder Typinitialisierer sein. Dieses Flag wird an eine InvokeMember-Methode übergeben, um eine Methode aufzurufen.
NonPublic	32	Gibt an, dass nicht öffentliche Member in die Suche einbezogen werden.
OptionalParamBinding	262144	Gibt die Menge der Member zurück, deren Parameteranzahl mit der Anzahl der bereitgestellten Argumente übereinstimmt. Dieses Bindungsflag wird für Methoden mit Parametern verwendet, die Standardwerte besitzen, und für Methoden mit variablen Argumenten (varargs). Dieses Flag sollte nur mit InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) verwendet werden. Parameter mit Standardwerten werden nur in Aufrufen verwendet, in denen nachfolgende Argumente ausgelassen werden. Sie müssen die letzten Argumente sein.
Public	16	Gibt an, dass öffentliche Member in die Suche einbezogen werden.
PutDispProperty	16384	Gibt an, dass der PROPPUT-Member für ein COM-Objekt aufgerufen werden soll. PROPPUT gibt eine Eigenschaften festlegende Funktion an, die einen Wert verwendet. Verwenden Sie PutDispProperty, wenn eine Eigenschaft sowohl PROPPUT als auch PROPPUTREF aufweist und Sie unterscheiden müssen, welche dieser beiden Optionen aufgerufen wird.
PutRefDispProperty	32768	Gibt an, dass der PROPPUTREF-Member für ein COM-Objekt aufgerufen werden soll. PROPPUTREF gibt eine Eigenschaften festlegende Funktion an, die einen Verweis anstelle eines Werts verwendet. Verwenden Sie PutRefDispProperty, wenn eine Eigenschaft sowohl PROPPUT als auch PROPPUTREF aufweist und Sie unterscheiden müssen, welche dieser beiden Optionen aufgerufen wird.
SetField	2048	Gibt an, dass der Wert des angegebenen Felds festgelegt werden soll. Dieses Flag wird an eine InvokeMember-Methode übergeben, um einen Feldwert festzulegen.
SetProperty	8192	Gibt an, dass der Wert der angegebenen Eigenschaft festgelegt werden soll. Bei COM-Eigenschaften ist die Angabe dieses Bindungsflags gleichbedeutend mit der Angabe von PutDispProperty und PutRefDispProperty. Dieses Flag wird an eine InvokeMember-Methode übergeben, um einen Setter für eine Eigenschaft aufzurufen.
Static	8	Gibt an, dass statische Member in die Suche einbezogen werden.
SuppressChangeType	131072	Nicht implementiert.

Beispiele

Im folgenden Beispiel werden viele der Bindungsflags veranschaulicht.

C#

using System;
using System.Reflection;
using System.IO;

namespace BindingFlagsSnippet
{
    class Example
    {
        static void Main()
        {
            // BindingFlags.InvokeMethod
            // Call a static method.
            Type t = typeof (TestClass);

            Console.WriteLine();
            Console.WriteLine("Invoking a static method.");
            Console.WriteLine("-------------------------");
            t.InvokeMember ("SayHello", BindingFlags.InvokeMethod | BindingFlags.Public |
                BindingFlags.Static, null, null, new object [] {});

            // BindingFlags.InvokeMethod
            // Call an instance method.
            TestClass c = new TestClass ();
            Console.WriteLine();
            Console.WriteLine("Invoking an instance method.");
            Console.WriteLine("----------------------------");
            c.GetType().InvokeMember ("AddUp", BindingFlags.InvokeMethod, null, c, new object [] {});
            c.GetType().InvokeMember ("AddUp", BindingFlags.InvokeMethod, null, c, new object [] {});

            // BindingFlags.InvokeMethod
            // Call a method with parameters.
            object [] args = new object [] {100.09, 184.45};
            object result;
            Console.WriteLine();
            Console.WriteLine("Invoking a method with parameters.");
            Console.WriteLine("---------------------------------");
            result = t.InvokeMember ("ComputeSum", BindingFlags.InvokeMethod, null, null, args);
            Console.WriteLine ("{0} + {1} = {2}", args[0], args[1], result);

            // BindingFlags.GetField, SetField
            Console.WriteLine();
            Console.WriteLine("Invoking a field (getting and setting.)");
            Console.WriteLine("--------------------------------------");
            // Get a field value.
            result = t.InvokeMember ("Name", BindingFlags.GetField, null, c, new object [] {});
            Console.WriteLine ("Name == {0}", result);
            // Set a field.
            t.InvokeMember ("Name", BindingFlags.SetField, null, c, new object [] {"NewName"});
            result = t.InvokeMember ("Name", BindingFlags.GetField, null, c, new object [] {});
            Console.WriteLine ("Name == {0}", result);

            Console.WriteLine();
            Console.WriteLine("Invoking an indexed property (getting and setting.)");
            Console.WriteLine("--------------------------------------------------");
            // BindingFlags.GetProperty
            // Get an indexed property value.
            int  index = 3;
            result = t.InvokeMember ("Item", BindingFlags.GetProperty, null, c, new object [] {index});
            Console.WriteLine ("Item[{0}] == {1}", index, result);
            // BindingFlags.SetProperty
            // Set an indexed property value.
            index = 3;
            t.InvokeMember ("Item", BindingFlags.SetProperty, null, c, new object [] {index, "NewValue"});
            result = t.InvokeMember ("Item", BindingFlags.GetProperty , null, c, new object [] {index});
            Console.WriteLine ("Item[{0}] == {1}", index, result);

            Console.WriteLine();
            Console.WriteLine("Getting a field or property.");
            Console.WriteLine("----------------------------");
            // BindingFlags.GetField
            // Get a field or property.
            result = t.InvokeMember ("Name", BindingFlags.GetField | BindingFlags.GetProperty, null, c,
                new object [] {});
            Console.WriteLine ("Name == {0}", result);
            // BindingFlags.GetProperty
            result = t.InvokeMember ("Value", BindingFlags.GetField | BindingFlags.GetProperty, null, c,
                new object [] {});
            Console.WriteLine ("Value == {0}", result);

            Console.WriteLine();
            Console.WriteLine("Invoking a method with named parameters.");
            Console.WriteLine("---------------------------------------");
            // BindingFlags.InvokeMethod
            // Call a method using named parameters.
            object[] argValues = new object [] {"Mouse", "Micky"};
            String [] argNames = new String [] {"lastName", "firstName"};
            t.InvokeMember ("PrintName", BindingFlags.InvokeMethod, null, null, argValues, null, null,
                argNames);

            Console.WriteLine();
            Console.WriteLine("Invoking a default member of a type.");
            Console.WriteLine("------------------------------------");
            // BindingFlags.Default
            // Call the default member of a type.
            Type t3 = typeof (TestClass2);
            t3.InvokeMember ("", BindingFlags.InvokeMethod | BindingFlags.Default, null, new TestClass2(),
                new object [] {});

            // BindingFlags.Static, NonPublic, and Public
            // Invoking a member with ref parameters.
            Console.WriteLine();
            Console.WriteLine("Invoking a method with ref parameters.");
            Console.WriteLine("--------------------------------------");
            MethodInfo m = t.GetMethod("Swap");
            args = new object[2];
            args[0] = 1;
            args[1] = 2;
            m.Invoke(new TestClass(),args);
            Console.WriteLine ("{0}, {1}", args[0], args[1]);

            // BindingFlags.CreateInstance
            // Creating an instance with a parameterless constructor.
            Console.WriteLine();
            Console.WriteLine("Creating an instance with a parameterless constructor.");
            Console.WriteLine("------------------------------------------------------");
            object cobj = t.InvokeMember ("TestClass", BindingFlags.Public |
                BindingFlags.Instance | BindingFlags.CreateInstance,
                null, null, new object [] {});
            Console.WriteLine("Instance of {0} created.", cobj.GetType().Name);

            // Creating an instance with a constructor that has parameters.
            Console.WriteLine();
            Console.WriteLine("Creating an instance with a constructor that has parameters.");
            Console.WriteLine("------------------------------------------------------------");
            cobj = t.InvokeMember ("TestClass", BindingFlags.Public |
                BindingFlags.Instance | BindingFlags.CreateInstance,
                null, null, new object [] { "Hello, World!" });
            Console.WriteLine("Instance of {0} created with initial value '{1}'.", cobj.GetType().Name,
                cobj.GetType().InvokeMember("Name", BindingFlags.GetField, null, cobj, null));

            // BindingFlags.DeclaredOnly
            Console.WriteLine();
            Console.WriteLine("DeclaredOnly instance members.");
            Console.WriteLine("------------------------------");
            System.Reflection.MemberInfo[] memInfo =
                t.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance |
                BindingFlags.Public);
            for(int i=0;i<memInfo.Length;i++)
            {
                Console.WriteLine(memInfo[i].Name);
            }

            // BindingFlags.IgnoreCase
            Console.WriteLine();
            Console.WriteLine("Using IgnoreCase and invoking the PrintName method.");
            Console.WriteLine("---------------------------------------------------");
            t.InvokeMember("printname", BindingFlags.IgnoreCase | BindingFlags.Static |
                BindingFlags.Public | BindingFlags.InvokeMethod, null, null, new object[]
                {"Brad","Smith"});

            // BindingFlags.FlattenHierarchy
            Console.WriteLine();
            Console.WriteLine("Using FlattenHierarchy to get inherited static protected and public members." );
            Console.WriteLine("----------------------------------------------------------------------------");
            FieldInfo[] finfos = typeof(MostDerived).GetFields(BindingFlags.NonPublic | BindingFlags.Public |
                  BindingFlags.Static | BindingFlags.FlattenHierarchy);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name);
            }

            Console.WriteLine();
            Console.WriteLine("Without FlattenHierarchy." );
            Console.WriteLine("-------------------------");
            finfos = typeof(MostDerived).GetFields(BindingFlags.NonPublic | BindingFlags.Public |
                  BindingFlags.Static);
            foreach (FieldInfo finfo in finfos)
            {
                Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name);
            }
        }
    }

    public class TestClass
    {
        public String Name;
        private Object [] values = new Object [] {0, 1,2,3,4,5,6,7,8,9};

        public Object this [int index]
        {
            get
            {
                return values[index];
            }
            set
            {
                values[index] = value;
            }
        }

        public Object Value
        {
            get
            {
                return "the value";
            }
        }

        public TestClass () : this("initialName") {}
        public TestClass (string initName)
        {
            Name = initName;
        }

        int methodCalled = 0;

        public static void SayHello ()
        {
            Console.WriteLine ("Hello");
        }

        public void AddUp ()
        {
            methodCalled++;
            Console.WriteLine ("AddUp Called {0} times", methodCalled);
        }

        public static double ComputeSum (double d1, double d2)
        {
            return d1 + d2;
        }

        public static void PrintName (String firstName, String lastName)
        {
            Console.WriteLine ("{0},{1}", lastName,firstName);
        }

        public void PrintTime ()
        {
            Console.WriteLine (DateTime.Now);
        }

        public void Swap(ref int a, ref int b)
        {
            int x = a;
            a = b;
            b = x;
        }
    }

    [DefaultMemberAttribute ("PrintTime")]
    public class TestClass2
    {
        public void PrintTime ()
        {
            Console.WriteLine (DateTime.Now);
        }
    }

    public class Base
    {
        static int BaseOnlyPrivate = 0;
        protected static int BaseOnly = 0;
    }
    public class Derived : Base
    {
        public static int DerivedOnly = 0;
    }
    public class MostDerived : Derived {}
}

/* This example produces output similar to the following:

Invoking a static method.
-------------------------
Hello

Invoking an instance method.
----------------------------
AddUp Called 1 times
AddUp Called 2 times

Invoking a method with parameters.
---------------------------------
100.09 + 184.45 = 284.54

Invoking a field (getting and setting.)
--------------------------------------
Name == initialName
Name == NewName

Invoking an indexed property (getting and setting.)
--------------------------------------------------
Item[3] == 3
Item[3] == NewValue

Getting a field or property.
----------------------------
Name == NewName
Value == the value

Invoking a method with named parameters.
---------------------------------------
Mouse,Micky

Invoking a default member of a type.
------------------------------------
12/23/2009 4:29:21 PM

Invoking a method with ref parameters.
--------------------------------------
2, 1

Creating an instance with a parameterless constructor.
------------------------------------------------------
Instance of TestClass created.

Creating an instance with a constructor that has parameters.
------------------------------------------------------------
Instance of TestClass created with initial value 'Hello, World!'.

DeclaredOnly instance members.
------------------------------
get_Item
set_Item
get_Value
AddUp
PrintTime
Swap
.ctor
.ctor
Item
Value
Name

Using IgnoreCase and invoking the PrintName method.
---------------------------------------------------
Smith,Brad

Using FlattenHierarchy to get inherited static protected and public members.
----------------------------------------------------------------------------
DerivedOnly defined in Derived.
BaseOnly defined in Base.

Without FlattenHierarchy.
-------------------------

 */

Hinweise

Diese BindingFlags Steuerelementbindung für eine Vielzahl von Klassen in den SystemNamespaces , System.Reflectionund System.Runtime , die Member und Typen aufrufen, erstellen, abrufen, festlegen und suchen.

BindingFlags werden in den folgenden Type Methoden und an anderen Stellen wie MethodBase.Invokeverwendet:

• MethodBase.Invoke

• GetMembers

• GetEvents

• InvokeMember

• Activator.CreateInstance

• GetConstructor

• GetConstructors

• GetMethod

• GetMethods

• GetField

• GetFields

• GetEvent

• GetProperty

• GetProperties

• GetMember

• FindMembers

InvokeMember und GetMethod sind besonders wichtig.

Die Bindungsflags können nach ihrer Identifizierung eines Typmembers kategorisiert werden, wie in der folgenden Tabelle aufgeführt.

Identifiziert durch Barrierefreiheit	Durch Bindungsargument identifiziert	Durch Vorgang identifiziert
DeclaredOnly FlattenHierarchy IgnoreCase IgnoreReturn Instanz Nonpublic Öffentlich statischen	ExactBinding OptionalParamBinding	CreateInstance GetField Setfield GetProperty SetProperty InvokeMethod PutDispProperty PutRefDispProperty

Hinweis

Sie müssen angeben Instance , dass zusammen Static mit Public oder oder NonPublic keine Member zurückgegeben werden.

In der folgenden Tabelle sind die Vom Standard Binder.ChangeTypeausgeführten Coercions aufgeführt. Diese Tabelle gilt insbesondere für das Bindungsflag BindingFlags.ExactBinding . Das allgemeine Prinzip ist, dass ChangeType nur breitere Zwinge durchgeführt werden sollten, die niemals Daten verlieren. Ein Beispiel für einen erweiternden Zwang ist das Erzwingen eines Werts, der eine 32-Bit-Ganzzahl mit Vorzeichen ist, in einen Wert, der eine 64-Bit-Ganzzahl mit Vorzeichen ist. Dies unterscheidet sich von einem einschränkenden Zwang, bei dem Daten verloren gehen können. Ein Beispiel für einen einschränkenden Zwang ist das Erzwingen einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen.

Quellentyp	Zieltyp
Beliebiger Typ	Sein Basistyp.
Beliebiger Typ	Die Schnittstelle, die implementiert wird.
Char	UInt16, UInt32, Int32, UInt64, Int64, Single, Double
Byte	Char, UInt16, Int16, UInt32, Int32, UInt64, Int64, Single, Double
SByte	Int16, Int32, Int64, Single, Double
UInt16	UInt32, Int32, UInt64, Int64, Single, Double
Int16	Int32, Int64, Single, Double
UInt32	UInt64, Int64, Single, Double
Int32	Int64, Single, Double
UInt64	Single, Double
Int64	Single, Double
Single	Double
Nicht-Verweis	NachVerweis.

Wenn das BindingFlags.ExactBinding Bindungsflag verwendet wird, modelliert die Reflektion die Barrierefreiheitsregeln des allgemeinen Typsystems. Wenn sich der Aufrufer beispielsweise in derselben Assembly befindet, benötigt der Aufrufer keine speziellen Berechtigungen für interne Member. Andernfalls benötigt ReflectionPermissionder Aufrufer . Dies ist konsistent mit der Suche von Mitgliedern, die geschützt, privat usw. sind.

Gilt für: