BindingFlags Enumeration

Definition

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.

public enum class BindingFlags
[System.Flags]
public enum BindingFlags
[System.Flags]
[System.Serializable]
public enum BindingFlags
[System.Flags]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum BindingFlags
[<System.Flags>]
type BindingFlags = 
[<System.Flags>]
[<System.Serializable>]
type BindingFlags = 
[<System.Flags>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type BindingFlags = 
Public Enum BindingFlags
Vererbung
BindingFlags
Attribute

Felder

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

using namespace System;
using namespace System::Collections;
using namespace System::Reflection;
using namespace System::IO;

//namespace BindingFlagsSnippet {
public ref class TestClass
{
public:
   String^ Name;

private:
   array<Object^>^ values;
   int methodCalled;

public:

   property Object^ Item [int]
   {
      Object^ get( int index )
      {
         return values[ index ];
      }

      void set( int index, Object^ value )
      {
         values[ index ] = value;
      }
   }

   property Object^ Value
   {
      Object^ get()
      {
         return "the value";
      }
   }

   TestClass() 
   {
      Name = "initialName";
      values = gcnew array<Object^> {(int^)0,1,2,3,4,5,6,7,8,9};
      methodCalled = 0;
   }
   
   TestClass(String^ initName)
   {
      Name = initName;
      values = gcnew array<Object^> {(int^)0,1,2,3,4,5,6,7,8,9};
      methodCalled = 0;
   }

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

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

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

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

   void PrintTime()
   {
      Console::WriteLine( DateTime::Now );
   }

   void Swap( interior_ptr<int> a, interior_ptr<int> b )
   {
      int x =  *a;
       *a =  *b;
       *b = x;
   }
};


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

};

public ref class Base
{
private:
    static int BaseOnlyPrivate = 0;
protected:
    static int BaseOnly = 0;
};

public ref class Derived : Base
{
public:
    static int DerivedOnly = 0;
};

public ref class MostDerived : Derived {};

void main()
{
   array<Object^>^ noArguments;

   // BindingFlags::InvokeMethod
   // Call a static method.
   Type^ t = TestClass::typeid;
   Console::WriteLine();
   Console::WriteLine( "Invoking a static method." );
   Console::WriteLine( "-------------------------" );
   t->InvokeMember( "SayHello", BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
         nullptr, nullptr, noArguments );

   // BindingFlags::InvokeMethod
   // Call an instance method.
   TestClass^ c = gcnew TestClass;
   Console::WriteLine();
   Console::WriteLine( "Invoking an instance method." );
   Console::WriteLine( "----------------------------" );
   c->GetType()->InvokeMember( "AddUp", BindingFlags::InvokeMethod, nullptr, c, noArguments );
   c->GetType()->InvokeMember( "AddUp", BindingFlags::InvokeMethod, nullptr, c, noArguments );

   // BindingFlags::InvokeMethod
   // Call a method with parameters.
   array<Object^>^args = {100.09,184.45};
   Object^ result;
   Console::WriteLine();
   Console::WriteLine( "Invoking a method with parameters." );
   Console::WriteLine( "---------------------------------" );
   result = t->InvokeMember( "ComputeSum", BindingFlags::InvokeMethod, nullptr, nullptr, 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, nullptr, c, noArguments );
   Console::WriteLine( "Name == {0}", result );

   // Set a field.
   array<Object^>^obj2 = {"NewName"};
   t->InvokeMember( "Name", BindingFlags::SetField, nullptr, c, obj2 );
   result = t->InvokeMember( "Name", BindingFlags::GetField, nullptr, c, noArguments );
   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;
   array<Object^>^obj3 = {index};
   result = t->InvokeMember( "Item", BindingFlags::GetProperty, nullptr, c, obj3 );
   Console::WriteLine( "Item->Item[ {0}] == {1}", index, result );

   // BindingFlags::SetProperty
   // Set an indexed property value.
   index = 3;
   array<Object^>^obj4 = {index,"NewValue"};
   t->InvokeMember( "Item", BindingFlags::SetProperty, nullptr, c, obj4 );
   result = t->InvokeMember( "Item", BindingFlags::GetProperty, nullptr, c, obj3 );
   Console::WriteLine( "Item->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", static_cast<BindingFlags>(BindingFlags::GetField | 
       BindingFlags::GetProperty), nullptr, c, noArguments );
   Console::WriteLine( "Name == {0}", result );

   // BindingFlags::GetProperty
   result = t->InvokeMember( "Value", static_cast<BindingFlags>(BindingFlags::GetField | 
       BindingFlags::GetProperty), nullptr, c, noArguments );
   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.
   array<Object^>^argValues = {"Mouse","Micky"};
   array<String^>^argNames = {"lastName","firstName"};
   t->InvokeMember( "PrintName", BindingFlags::InvokeMethod, nullptr, nullptr, argValues, nullptr, 
       nullptr, 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 = TestClass2::typeid;
   t3->InvokeMember( "", static_cast<BindingFlags>(BindingFlags::InvokeMethod | BindingFlags::Default), 
        nullptr, gcnew TestClass2, noArguments );

   // 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 = gcnew array<Object^>(2);
   args[ 0 ] = 1;
   args[ 1 ] = 2;
   m->Invoke( gcnew 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^ obj = t->InvokeMember( "TestClass", static_cast<BindingFlags>(BindingFlags::Public | 
       BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, nullptr, noArguments );
   Console::WriteLine("Instance of {0} created.", obj->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( "------------------------------------------------------------" );
   obj = t->InvokeMember( "TestClass", static_cast<BindingFlags>(BindingFlags::Public | 
       BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, nullptr, 
       gcnew array<Object^> { "Hello, World!" } );
   Console::WriteLine("Instance of {0} created with initial value '{1}'.", obj->GetType()->Name, 
       obj->GetType()->InvokeMember("Name", BindingFlags::GetField, nullptr, obj, noArguments));

   // BindingFlags::DeclaredOnly
   Console::WriteLine();
   Console::WriteLine( "DeclaredOnly instance members." );
   Console::WriteLine( "------------------------------" );
   array<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", static_cast<BindingFlags>(BindingFlags::IgnoreCase | 
                BindingFlags::Static | BindingFlags::Public | BindingFlags::InvokeMethod), 
                nullptr, nullptr, gcnew array<Object^> {"Brad","Smith"});

   // BindingFlags::FlattenHierarchy
   Console::WriteLine();
   Console::WriteLine( "Using FlattenHierarchy to get inherited static protected and public members." );
   Console::WriteLine( "----------------------------------------------------------------------------" );
   array<FieldInfo^>^ finfos = MostDerived::typeid->GetFields(BindingFlags::NonPublic | 
         BindingFlags::Public | BindingFlags::Static | BindingFlags::FlattenHierarchy);
   for each (FieldInfo^ finfo in finfos)
   {
       Console::WriteLine("{0} defined in {1}.", finfo->Name, finfo->DeclaringType->Name);
   }

   Console::WriteLine();
   Console::WriteLine("Without FlattenHierarchy." );
   Console::WriteLine("-------------------------");
   finfos = MostDerived::typeid->GetFields(BindingFlags::NonPublic | BindingFlags::Public |
         BindingFlags::Static);
   for each (FieldInfo^ finfo in finfos)
   {
       Console::WriteLine("{0} defined in {1}.", finfo->Name, finfo->DeclaringType->Name);
   }
};

/* 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->Item[ 3] == 3
Item->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:19:06 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
Value
Item
Name
methodCalled

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

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

 */
Imports System.Reflection
Imports System.IO

Class Invoke

    Public Shared Sub Main()
        ' BindingFlags.InvokeMethod
        ' Call a static method.
        Dim t As Type = GetType(TestClass)

        Console.WriteLine()
        Console.WriteLine("Invoking a static method.")
        Console.WriteLine("-------------------------")
        t.InvokeMember("SayHello", BindingFlags.InvokeMethod Or BindingFlags.Public _
            Or BindingFlags.Static, Nothing, Nothing, New Object() {})

        ' BindingFlags.InvokeMethod
        ' Call an instance method.
        Dim c As New TestClass()
        Console.WriteLine()
        Console.WriteLine("Invoking an instance method.")
        Console.WriteLine("----------------------------")
        c.GetType().InvokeMember("AddUp", BindingFlags.InvokeMethod, Nothing, c, New Object() {})
        c.GetType().InvokeMember("AddUp", BindingFlags.InvokeMethod, Nothing, c, New Object() {})

        ' BindingFlags.InvokeMethod
        ' Call a method with parameters.
        Dim args() As Object = {100.09, 184.45}
        Dim result As Object
        Console.WriteLine()
        Console.WriteLine("Invoking a method with parameters.")
        Console.WriteLine("---------------------------------")
        result = t.InvokeMember("ComputeSum", BindingFlags.InvokeMethod, Nothing, Nothing, 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, Nothing, c, New Object() {})
        Console.WriteLine("Name == {0}", result)
        ' Set a field.
        t.InvokeMember("Name", BindingFlags.SetField, Nothing, c, New Object() {"NewName"})
        result = t.InvokeMember("Name", BindingFlags.GetField, Nothing, 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.
        Dim index As Integer = 3
        result = t.InvokeMember("Item", BindingFlags.GetProperty, Nothing, 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, Nothing, c, New Object() {index, "NewValue"})
        result = t.InvokeMember("Item", BindingFlags.GetProperty, Nothing, 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 Or BindingFlags.GetProperty, Nothing, _
            c, New Object() {})
        Console.WriteLine("Name == {0}", result)
        ' BindingFlags.GetProperty
        result = t.InvokeMember("Value", BindingFlags.GetField Or BindingFlags.GetProperty, Nothing, _
            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.
        Dim argValues() As Object = {"Mouse", "Micky"}
        Dim argNames() As [String] = {"lastName", "firstName"}
        t.InvokeMember("PrintName", BindingFlags.InvokeMethod, Nothing, Nothing, argValues, Nothing, _
            Nothing, argNames)

        Console.WriteLine()
        Console.WriteLine("Invoking a default member of a type.")
        Console.WriteLine("------------------------------------")
        ' BindingFlags.Default
        ' Call the default member of a type.
        Dim t3 As Type = GetType(TestClass2)
        t3.InvokeMember("", BindingFlags.InvokeMethod Or BindingFlags.Default, Nothing, _
            New TestClass2(), New Object() {})

        Console.WriteLine()
        Console.WriteLine("Invoking a method with ByRef parameters.")
        Console.WriteLine("----------------------------------------")
        ' BindingFlags.Static, NonPublic, and Public
        ' Invoking a member by reference.
        Dim m As MethodInfo = t.GetMethod("Swap")
        args = New Object(1) {}
        args(0) = 1
        args(1) = 2
        m.Invoke(New TestClass(), args)
        Console.WriteLine("{0}, {1}", args(0), args(1))

        ' BindingFlags.CreateInstance
        ' Creating an instance.
        Console.WriteLine()
        Console.WriteLine("Creating an instance with parameterless constructor.")
        Console.WriteLine("----------------------------------------------------")
        Dim obj As Object = GetType(TestClass).InvokeMember("TestClass", BindingFlags.CreateInstance, _
            Nothing, Nothing, New Object() {})
        Console.WriteLine("Instance of {0} created.", obj.GetType().Name)

        Console.WriteLine()
        Console.WriteLine("Creating an instance with a constructor that has parameters.")
        Console.WriteLine("------------------------------------------------------------")
        obj = GetType(TestClass).InvokeMember("TestClass", BindingFlags.CreateInstance, Nothing, _
            Nothing, New Object() { "Hello, World!" })
        Console.WriteLine("Instance of {0} created with initial value '{1}'.", obj.GetType().Name, _
            obj.GetType().InvokeMember("Name", BindingFlags.GetField, Nothing, obj, Nothing))

        ' BindingFlags.DeclaredOnly
        Console.WriteLine()
        Console.WriteLine("DeclaredOnly instance members.")
        Console.WriteLine("------------------------------")
        Dim memInfo As System.Reflection.MemberInfo() = t.GetMembers(BindingFlags.DeclaredOnly Or _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim i As Integer
        For i = 0 To memInfo.Length - 1
            Console.WriteLine(memInfo(i).Name)
        Next i

        ' BindingFlags.IgnoreCase
        Console.WriteLine()
        Console.WriteLine("Using IgnoreCase and invoking the PrintName method.")
        Console.WriteLine("---------------------------------------------------")
        t.InvokeMember("printname", BindingFlags.IgnoreCase Or BindingFlags.Public Or _
            BindingFlags.Static Or BindingFlags.InvokeMethod, Nothing, Nothing, _
            New Object() {"Brad", "Smith"})

        ' BindingFlags.FlattenHierarchy
        Console.WriteLine()
        Console.WriteLine("Using FlattenHierarchy to get inherited static protected and public members." )
        Console.WriteLine("----------------------------------------------------------------------------")
        Dim finfos() As FieldInfo = GetType(MostDerived).GetFields(BindingFlags.NonPublic Or _
              BindingFlags.Public Or BindingFlags.Static Or BindingFlags.FlattenHierarchy)
        For Each finfo As FieldInfo In finfos
            Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name)
        Next

        Console.WriteLine()
        Console.WriteLine("Without FlattenHierarchy." )
        Console.WriteLine("-------------------------")
        finfos = GetType(MostDerived).GetFields(BindingFlags.NonPublic Or BindingFlags.Public Or _
              BindingFlags.Static)
        For Each finfo As FieldInfo In finfos
            Console.WriteLine("{0} defined in {1}.", finfo.Name, finfo.DeclaringType.Name)
        Next
    End Sub
End Class

Public Class TestClass
    Public Name As String
    Private values() As [Object] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    Default Public Property Item(ByVal index As Integer) As [Object]
        Get
            Return values(index)
        End Get
        Set(ByVal Value As [Object])
            values(index) = Value
        End Set
    End Property

    Public ReadOnly Property Value() As [Object]
        Get
            Return "the value"
        End Get
    End Property

    Public Sub New(ByVal initName As String)
        Name = initName
    End Sub 

    Public Sub New()
        MyClass.New("initialName")
    End Sub 

    Private methodCalled As Integer = 0

    Public Shared Sub SayHello()
        Console.WriteLine("Hello")
    End Sub 

    Public Sub AddUp()
        methodCalled += 1
        Console.WriteLine("AddUp Called {0} times", methodCalled)
    End Sub 

    Public Shared Function ComputeSum(ByVal d1 As Double, ByVal d2 As Double) As Double
        Return d1 + d2
    End Function 

    Public Shared Sub PrintName(ByVal firstName As [String], ByVal lastName As [String])
        Console.WriteLine("{0},{1}", lastName, firstName)
    End Sub 

    Public Sub PrintTime()
        Console.WriteLine(DateTime.Now)
    End Sub 

    Public Sub Swap(ByRef a As Integer, ByRef b As Integer)
        Dim x As Integer = a
        a = b
        b = x
    End Sub
End Class

<DefaultMemberAttribute("PrintTime")> _
Public Class TestClass2

    Public Sub PrintTime()
        Console.WriteLine(DateTime.Now)
    End Sub 
End Class

Public Class Base
    Shared BaseOnlyPrivate As Integer = 0
    Protected Shared BaseOnly As Integer = 0
End Class

Public Class Derived 
    Inherits Base
    Public Shared DerivedOnly As Integer = 0
End Class

Public Class MostDerived 
    Inherits Derived
End Class

' 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:34:22 PM
'
'Invoking a method with ByRef parameters.
'----------------------------------------
'2, 1
'
'Creating an instance with 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 Steuerelementbindung für eine große Anzahl von BindingFlags Klassen in den System, System.Reflectionund System.Runtime Namespaces, die Aufrufen, Erstellen, Abrufen, Festlegen und Suchen von Elementen und Typen.

BindingFlags werden in den folgenden Type Methoden und anderen Orten verwendet, z MethodBase.Invoke. B. :

InvokeMember und GetMethod sind besonders wichtig.

Die Bindungskennzeichnungen können kategorisiert werden, indem sie ein Typelement identifizieren, wie in der folgenden Tabelle aufgeführt.

Identifiziert durch Barrierefreiheit Durch Bindungsargument identifiziert Durch Vorgang identifiziert
DeklariertOnly

FlattenHierarchy

IgnoreCase

IgnoreReturn

Instanz

Nonpublic

Öffentlich

statischen
ExactBinding

OptionalParamBinding
CreateInstance

GetField

Setfield

GetProperty

SetProperty

InvokeMethod

PutDispProperty

PutRefDispProperty

Hinweis

Sie müssen angeben Instance oder Static zusammen mit Public oder NonPublic ohne Mitglieder zurückgegeben werden.

In der folgenden Tabelle sind die Koerzionen aufgeführt, die standardmäßig Binder.ChangeTypeausgeführt werden. Diese Tabelle gilt insbesondere für das BindingFlags.ExactBinding Bindungszeichen. Das allgemeine Prinzip besteht darin, dass ChangeType nur Verbreiterungskoerionen ausgeführt werden sollen, die niemals Daten verlieren. Ein Beispiel für eine Verbreiterung des Koercions ist das Coercion eines Werts, der eine 32-Bit-Ganzzahl ist, auf einen Wert, der eine 64-Bit-signierte ganze Zahl ist. Dies unterscheidet sich von einem schmalen Koercion, der möglicherweise Daten verliert. Ein Beispiel für einen schmalen Koercion ist das Coercion, das eine 64-Bit-Ganzzahl mit einer 32-Bit-Ganzzahl zusammenfasst.

Quellentyp Zieltyp
Beliebiger Typ Der Basistyp.
Beliebiger Typ Die schnittstelle, die sie implementiert.
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
Keine Referenz Nachverweis.

Wenn das BindingFlags.ExactBinding Bindungskennzeichnung verwendet wird, werden die Barrierefreiheitsregeln des allgemeinen Typsystems durch Spiegelungsmodelle modelliert. Wenn sich der Aufrufer beispielsweise in derselben Assembly befindet, benötigt der Aufrufer keine speziellen Berechtigungen für interne Mitglieder. Andernfalls benötigt ReflectionPermissionder Anrufer . Dies entspricht der Nachschlagevorgang von Mitgliedern, die geschützt, privat usw. sind.

Gilt für