BindingFlags Enum

Reference

Definition

Namespace:: System.Reflection

Assemblies:: mscorlib.dll, System.Reflection.TypeExtensions.dll

Assembly:: System.Runtime.dll

Assembly:: System.Reflection.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Specifies flags that control binding and the way in which the search for members and types is conducted by reflection.

This enumeration supports a bitwise combination of its member values.

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

Inheritance: Object

ValueType

Enum
BindingFlags

Attributes: FlagsAttribute SerializableAttribute ComVisibleAttribute

Fields

Name	Value	Description
Default	0	Specifies that no binding flags are defined.
IgnoreCase	1	Specifies that the case of the member name should not be considered when binding.
DeclaredOnly	2	Specifies that only members declared at the level of the supplied type's hierarchy should be considered. Inherited members are not considered.
Instance	4	Specifies that instance members are to be included in the search.
Static	8	Specifies that static members are to be included in the search.
Public	16	Specifies that public members are to be included in the search.
NonPublic	32	Specifies that non-public members are to be included in the search.
FlattenHierarchy	64	Specifies that public and protected static members up the hierarchy should be returned. Private static members in inherited classes are not returned. Static members include fields, methods, events, and properties. Nested types are not returned.
InvokeMethod	256	Specifies that a method is to be invoked. This must not be a constructor or a type initializer. This flag is passed to an `InvokeMember` method to invoke a method.
CreateInstance	512	Specifies that reflection should create an instance of the specified type. Calls the constructor that matches the given arguments. The supplied member name is ignored. If the type of lookup is not specified, (Instance \| Public) will apply. It is not possible to call a type initializer. This flag is passed to an `InvokeMember` method to invoke a constructor.
GetField	1024	Specifies that the value of the specified field should be returned. This flag is passed to an `InvokeMember` method to get a field value.
SetField	2048	Specifies that the value of the specified field should be set. This flag is passed to an `InvokeMember` method to set a field value.
GetProperty	4096	Specifies that the value of the specified property should be returned. This flag is passed to an `InvokeMember` method to invoke a property getter.
SetProperty	8192	Specifies that the value of the specified property should be set. For COM properties, specifying this binding flag is equivalent to specifying `PutDispProperty` and `PutRefDispProperty`. This flag is passed to an `InvokeMember` method to invoke a property setter.
PutDispProperty	16384	Specifies that the `PROPPUT` member on a COM object should be invoked. `PROPPUT` specifies a property-setting function that uses a value. Use `PutDispProperty` if a property has both `PROPPUT` and `PROPPUTREF` and you need to distinguish which one is called.
PutRefDispProperty	32768	Specifies that the `PROPPUTREF` member on a COM object should be invoked. `PROPPUTREF` specifies a property-setting function that uses a reference instead of a value. Use `PutRefDispProperty` if a property has both `PROPPUT` and `PROPPUTREF` and you need to distinguish which one is called.
ExactBinding	65536	Specifies that types of the supplied arguments must exactly match the types of the corresponding formal parameters. Reflection throws an exception if the caller supplies a non-null `Binder` object, since that implies that the caller is supplying `BindToXXX` implementations that will pick the appropriate method. The default binder ignores this flag, while custom binders can implement the semantics of this flag.
SuppressChangeType	131072	Not implemented.
OptionalParamBinding	262144	Returns the set of members whose parameter count matches the number of supplied arguments. This binding flag is used for methods with parameters that have default values and methods with variable arguments (varargs). This flag should only be used with InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Parameters with default values are used only in calls where trailing arguments are omitted. They must be the last arguments.
IgnoreReturn	16777216	Used in COM interop to specify that the return value of the member can be ignored.
DoNotWrapExceptions	33554432	Specifies that exceptions should not be wrapped in a TargetInvocationException.

Examples

The following example demonstrates many of the binding flags.

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

Remarks

These BindingFlags control binding for a great many classes in the System, System.Reflection, and System.Runtime namespaces that invoke, create, get, set, and find members and types.

BindingFlags are used in the following Type methods and other places such as MethodBase.Invoke:

InvokeMember and GetMethod are especially important.

The binding flags can be categorized by how they identify a type member, as listed in the following table.

Identified by Accessibility	Identified by Binding Argument	Identified by Operation
DeclaredOnly FlattenHierarchy IgnoreCase IgnoreReturn Instance NonPublic Public Static	ExactBinding OptionalParamBinding	CreateInstance GetField SetField GetProperty SetProperty InvokeMethod PutDispProperty PutRefDispProperty

Note

You must specify Instance or Static along with Public or NonPublic or no members will be returned.

The following table lists the coercions performed by the default Binder.ChangeType. This table applies especially to the BindingFlags.ExactBinding binding flag. The general principle is that ChangeType should perform only widening coercions, which never lose data. An example of a widening coercion is coercing a value that is a 32-bit signed integer to a value that is a 64-bit signed integer. This is distinguished from a narrowing coercion, which may lose data. An example of a narrowing coercion is coercing a 64-bit signed integer to a 32-bit signed integer.

Source Type	Target Type
Any type	Its base type.
Any type	The interface it implements.
`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`
Non-reference	By-reference.

When the BindingFlags.ExactBinding binding flag is used, reflection models the accessibility rules of the common type system. For example, if the caller is in the same assembly, the caller does not need special permissions for internal members. Otherwise, the caller needs ReflectionPermission. This is consistent with the lookup of members that are protected, private, and so on.

Applies to

Κοινή χρήση μέσω