BindingFlags 列挙体とは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

BindingFlags 列挙体

バインディング、およびリフレクションによるメンバと型の検索方法を制御するフラグを指定します。

この列挙体には、メンバ値のビットごとの組み合わせを可能にする FlagsAttribute 属性が含まれています。

名前空間: System.Reflection
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<FlagsAttribute> _
Public Enumeration BindingFlags

Visual Basic (使用法)

Dim instance As BindingFlags

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum BindingFlags

C++

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum class BindingFlags

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute FlagsAttribute() */ 
public enum BindingFlags

JScript

SerializableAttribute 
ComVisibleAttribute(true) 
FlagsAttribute 
public enum BindingFlags

メンバ

	メンバ名	説明
	CreateInstance	リフレクションが指定した型のインスタンスを作成するように指定します。指定した引数と一致するコンストラクタを呼び出します。指定したメンバ名は無視されます。検索の種類を省略した場合は、(Instance \| Public) が適用されます。タイプ初期化子を呼び出すことはできません。
	DeclaredOnly	指定した型の階層のレベルで宣言されたメンバだけが対象になるように指定します。継承されたメンバは対象になりません。
	Default	バインディングフラグを指定しません。
	ExactBinding	指定した引数の型が、対応する仮パラメータの型と完全に一致する必要があることを指定します。呼び出し元が非 null Binder オブジェクトを指定した場合、これは適切なメソッドをピックする BindToXXX 実装を呼び出し元が提供することを意味するため、リフレクションは例外をスローします。リフレクションは、共通型システムにおけるアクセスに関する規則をモデル化します。たとえば、呼び出し元が同一アセンブリ内にある場合、呼び出し元に内部メンバに対する特別なアクセス許可は必要ありません。それ以外の場合は、呼び出し元に ReflectionPermission が必要です。このことは、プロテクトメンバ、プライベートメンバなどを検索する場合も同様です。一般原則として、データを失わないように、ChangeType は型の強制拡大変換だけを実行します。型の強制拡大変換の例としては、32 ビット符号付き整数値から 64 ビット符号付き整数値への強制変換があります。この変換は、データが失われる可能性がある、型の強制縮小変換とは区別されます。型の強制縮小変換の例としては、64 ビット符号付き整数から 32 ビット符号付き整数への強制変換があります。既定のバインダはこのフラグを無視しますが、カスタムバインダはこのフラグのセマンティクスを実装できます。
	FlattenHierarchy	階層上位のパブリックおよびプロテクトの静的メンバを返す場合に指定します。継承クラスのプライベートな静的メンバは返されません。静的メンバには、フィールド、メソッド、イベント、プロパティなどがあります。入れ子にされた型は返されません。
	GetField	指定したフィールドの値を返すように指定します。
	GetProperty	指定したプロパティの値を返すように指定します。
	IgnoreCase	バインディングのときにメンバ名の大文字小文字を区別しないように指定します。
	IgnoreReturn	COM 相互運用で使用して、メンバの戻り値を無視できることを指定します。
	Instance	インスタンスメンバを検索に含めるように指定します。
	InvokeMethod	メソッドを呼び出すように指定します。コンストラクタとタイプ初期化子は指定できません。
	NonPublic	非パブリックメンバを検索に含めるように指定します。
	OptionalParamBinding	パラメータ数が指定された引数の数と一致するメンバのセットを返します。このバインディングフラグは、既定値を持つパラメータをとるメソッドと、可変個の引数 (varargs) をとるメソッドで使用します。このフラグを使用するときは、必ず Type.InvokeMember も使用します。既定値を持つパラメータを呼び出しで使用できるのは、それ以後の引数が省略されている場合だけです。そのパラメータが最後の引数になります。
	Public	パブリックメンバを検索に含めるように指定します。
	PutDispProperty	COM オブジェクトの PROPPUT メンバを呼び出す必要があることを指定します。PROPPUT は、値を使用するプロパティ設定関数を指定します。プロパティに PROPPUT と PROPPUTREF の両方があり、どちらを呼び出すかを区別する必要がある場合は、PutDispProperty を使用します。
	PutRefDispProperty	COM オブジェクトの PROPPUTREF メンバを呼び出す必要があることを指定します。PROPPUTREF は、値の代わりに参照を使用するプロパティ設定関数を指定します。プロパティに PROPPUT と PROPPUTREF の両方があり、どちらを呼び出すかを区別する必要がある場合は、PutRefDispProperty を使用します。
	SetField	指定したフィールドの値を設定するように指定します。
	SetProperty	指定したプロパティの値を設定するように指定します。COM プロパティの場合、このバインディングフラグを指定することは、PutDispProperty と PutRefDispProperty を指定することと同じです。
	Static	静的メンバを検索に含めるように指定します。
	SuppressChangeType	実装されていません。

解説

これらの BindingFlags は、メンバと型の呼び出し、作成、取得、設定、および検索を行う System、System.Reflection、System.Runtime の各名前空間の多くのクラスのバインディングを制御します。

BindingFlags は、次の Type メソッドや MethodBase.Invoke などで使用します。

MethodBase.Invoke
GetMembers
GetEvents
InvokeMember
Activator.CreateInstance
GetConstructor
GetConstructors
GetMethod
GetMethods
GetField
GetFields
GetEvent
GetProperty
GetProperties
GetMember
FindMembers

InvokeMember と GetMethod は、特に重要です。

次の表に示すように、バインディングフラグは、型のメンバをどのように識別するかで分類できます。

アクセシビリティで識別	バインディング引数で識別	操作で識別
DeclaredOnly FlattenHierarchy IgnoreCase IgnoreReturn Instance NonPublic Public Static	ExactBinding OptionalParamBinding	CreateInstance GetField SetField GetProperty SetProperty InvokeMethod PutDispProperty PutRefDispProperty

アクセシビリティで識別

バインディング引数で識別

操作で識別

DeclaredOnly

FlattenHierarchy

IgnoreCase

IgnoreReturn

Instance

NonPublic

Public

Static

ExactBinding

OptionalParamBinding

CreateInstance

GetField

SetField

GetProperty

SetProperty

InvokeMethod

PutDispProperty

PutRefDispProperty

メモ
Public または NonPublic と共に、Instance または Static を指定する必要があります。指定しない場合、メンバが返されません。

既定の Binder.ChangeType で実行される型の強制変換の一覧を次の表に示します。この表は、特に ExactBinding バインディングフラグに適用されます。

変換元の型	変換後の型
任意の型	基本型
任意の型	実装するインターフェイス
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
非参照渡し	参照渡し

使用例

各バインディングフラグの例を次に示します。

Visual Basic

Imports System
Imports System.Reflection
Imports System.IO

Class EntryPoint
    Overloads Shared Sub
 Main(ByVal args() As String)
        Invoke.Go()
    End Sub 'Main
End Class 'EntryPoint



Class Invoke

    Public Shared Sub Go()
        ' 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,
 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 by reference.")
        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))
        ' The string is case-sensitive.
        Dim type As Type = type.GetType("System.String")

        ' Check to see if the value is valid. If the object is null,
 the type does not exist.
        If type Is Nothing
 Then
            Console.WriteLine("Please ensure that you specify
 only valid types in the type field.")
            Console.WriteLine("The type name is case-sensitive.")
            Return
        End If
        ' Declare and populate the arrays to hold the information.
        ' You must declare either NonPublic or Public with Static or
 the search will not work.
        Dim fi As FieldInfo() = type.GetFields((BindingFlags.Static
 Or BindingFlags.NonPublic Or BindingFlags.Public))
        ' BindingFlags.NonPublic 
        Dim miNonPublic As MethodInfo() = type.GetMethods((BindingFlags.Static
 Or BindingFlags.NonPublic))
        ' BindingFlags.Public
        Dim miPublic As MethodInfo() = type.GetMethods((BindingFlags.Static
 Or BindingFlags.Public))

        ' Iterate through all the nonpublic methods.
        Dim method As MethodInfo
        For Each method In
 miNonPublic
            Console.WriteLine(method)
        Next method
        ' Iterate through all the public methods.
        For Each method In
 miPublic
            Console.WriteLine(method)
        Next method
        ' Iterate through all the fields.
        Dim f As FieldInfo
        For Each f In fi
            Console.WriteLine(f)
        Next f

        ' Call an instance method.
        Dim tc As New TestClass()
        Console.WriteLine()
        Console.WriteLine("Invoking an Instance method.")
        Console.WriteLine("----------------------------")
        tc.GetType().InvokeMember("AddUp", BindingFlags.Public
 Or BindingFlags.Instance Or BindingFlags.CreateInstance,
 Nothing, tc, New Object() {})

        ' BindingFlags.CreateInstance
        ' Calling and creating an instance method.
        Console.WriteLine()
        Console.WriteLine("Invoking and creating an instance method.")
        Console.WriteLine("-----------------------------------------")
        tc.GetType().InvokeMember("AddUp", BindingFlags.Public
 Or BindingFlags.Instance Or BindingFlags.CreateInstance,
 Nothing, tc, New Object() {})

        ' BindingFlags.DeclaredOnly
        Dim tc2 As New TestClass()
        Console.WriteLine()
        Console.WriteLine("DeclaredOnly members")
        Console.WriteLine("---------------------------------")
        Dim memInfo As System.Reflection.MemberInfo()
 = tc2.GetType().GetMembers(BindingFlags.DeclaredOnly)
        Dim i As Integer
        For i = 0 To memInfo.Length - 1
            Console.WriteLine(memInfo(i).Name)
        Next i

        ' BindingFlags.SuppressChangeType
        Dim obj As New TestClass()
        Console.WriteLine()
        Console.WriteLine("Invoking static method - PrintName")
        Console.WriteLine("---------------------------------")
        Dim methInfo As System.Reflection.MethodInfo
 = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.SuppressChangeType Or
 BindingFlags.InvokeMethod, Nothing, New Object()
 {"Brad", "Smith"}, Nothing)

        ' BindingFlags.IgnoreCase
        Console.WriteLine()
        Console.WriteLine("Using IgnoreCase and invoking the PrintName
 method.")
        Console.WriteLine("---------------------------------------------------")
        methInfo = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.IgnoreCase Or BindingFlags.InvokeMethod,
 Nothing, New Object()
 {"brad", "smith"}, Nothing)

        ' BindingFlags.IgnoreReturn
        Console.WriteLine()
        Console.WriteLine("Using IgnoreReturn and invoking the
 PrintName method.")
        Console.WriteLine("-----------------------------------------------------")
        methInfo = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.IgnoreReturn Or BindingFlags.InvokeMethod,
 Nothing, New Object()
 {"Brad", "Smith"}, Nothing)

        ' BindingFlags.OptionalParamBinding
        Console.WriteLine()
        Console.WriteLine("Using OptionalParamBinding and invoking
 the PrintName method.")
        Console.WriteLine("-------------------------------------------------------------")
        methInfo = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.OptionalParamBinding Or
 BindingFlags.InvokeMethod, Nothing, New Object()
 {"Brad", "Smith"}, Nothing)

        ' BindingFlags.ExactBinding
        Console.WriteLine()
        Console.WriteLine("Using ExactBinding and invoking the
 PrintName method.")
        Console.WriteLine("-----------------------------------------------------")
        methInfo = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.ExactBinding Or BindingFlags.InvokeMethod,
 Nothing, New Object()
 {"Brad", "Smith"}, Nothing)

        ' BindingFlags.FlattenHierarchy
        Console.WriteLine()
        Console.WriteLine("Using FlattenHierarchy and invoking
 the PrintName method.")
        Console.WriteLine("---------------------------------------------------------")
        methInfo = obj.GetType().GetMethod("PrintName")
        methInfo.Invoke(obj, BindingFlags.FlattenHierarchy Or
 BindingFlags.InvokeMethod, Nothing, New Object()
 {"Brad", "Smith"}, Nothing)
    End Sub 'Go
End Class 'Invoke

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()
        Name = "initialName"
    End Sub 'New

    Private methodCalled As Integer
 = 0


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


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


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


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


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


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

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

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

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

namespace BindingFlagsSnippet
{
    class EntryPoint
    {
        static void Main(string[]
 args)
        {
            Invoke.Go();
        }
    }

    
    class Invoke
    {
        public static void
 Go()
        {
            // 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, 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 by reference.
            Console.WriteLine();
            Console.WriteLine("Invoking a method by reference.");
            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]);
            // The string is case-sensitive.
            Type type = Type.GetType("System.String");

            // Check to see if the value is valid. If the object is
 null, the type does not exist.
            if (type == null) 
            {
                Console.WriteLine("Please ensure that you specify only valid
 types in the type field.");
                Console.WriteLine("The type name is case-sensitive.");
                return;
            }
            // Declare and populate the arrays to hold the information.
            // You must declare either NonPublic or Public with Static
 or the search will not work.
            FieldInfo [] fi = type.GetFields (BindingFlags.Static |
                BindingFlags.NonPublic | BindingFlags.Public);  
            // BindingFlags.NonPublic 
            MethodInfo [] miNonPublic = type.GetMethods (BindingFlags.Static |
                BindingFlags.NonPublic);
            // BindingFlags.Public
            MethodInfo [] miPublic = type.GetMethods (BindingFlags.Static |
                BindingFlags.Public);

            // Iterate through all the nonpublic methods.
            foreach (MethodInfo method in miNonPublic)
 
            {
                Console.WriteLine(method);
            }
            // Iterate through all the public methods.
            foreach (MethodInfo method in miPublic)
 
            {
                Console.WriteLine(method);
            }
            // Iterate through all the fields.
            foreach (FieldInfo f in fi) 
            {
                Console.WriteLine(f);
            }

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

            // BindingFlags.CreateInstance
            // Calling and creating an instance method.
            Console.WriteLine();
            Console.WriteLine("Invoking and creating an instance method.");
            Console.WriteLine("-----------------------------------------");
            tc.GetType().InvokeMember ("AddUp", BindingFlags.Public | 
                BindingFlags.Instance | BindingFlags.CreateInstance, 
                null, tc, new object [] {});

            // BindingFlags.DeclaredOnly
            TestClass tc2 = new TestClass();
            Console.WriteLine();
            Console.WriteLine("DeclaredOnly members");
            Console.WriteLine("---------------------------------");
            System.Reflection.MemberInfo[] memInfo = 
                tc2.GetType().GetMembers(BindingFlags.DeclaredOnly);
            for(int i=0;i<memInfo.Length;i++)
 
            {
                Console.WriteLine(memInfo[i].Name);
            }

            // BindingFlags.SuppressChangeType
            TestClass obj = new TestClass();
            Console.WriteLine();
            Console.WriteLine("Invoking static method - PrintName");
            Console.WriteLine("---------------------------------");
            System.Reflection.MethodInfo methInfo = 
                obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.SuppressChangeType | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"Brad","Smith"},null);

            // BindingFlags.IgnoreCase
            Console.WriteLine();
            Console.WriteLine("Using IgnoreCase and invoking the PrintName method.");
            Console.WriteLine("---------------------------------------------------");
            methInfo = obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.IgnoreCase | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"brad","smith"},null);

            // BindingFlags.IgnoreReturn
            Console.WriteLine();
            Console.WriteLine("Using IgnoreReturn and invoking the PrintName
 method.");
            Console.WriteLine("-----------------------------------------------------");
            methInfo = obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.IgnoreReturn | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"Brad","Smith"},null);

            // BindingFlags.OptionalParamBinding
            Console.WriteLine();
            Console.WriteLine("Using OptionalParamBinding and invoking the PrintName
 method.");
            Console.WriteLine("-------------------------------------------------------------");
            methInfo = obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.OptionalParamBinding | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"Brad","Smith"},null);

            // BindingFlags.ExactBinding
            Console.WriteLine();
            Console.WriteLine("Using ExactBinding and invoking the PrintName
 method.");
            Console.WriteLine("-----------------------------------------------------");
            methInfo = obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.ExactBinding | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"Brad","Smith"},null);
 
            // BindingFlags.FlattenHierarchy
            Console.WriteLine();
            Console.WriteLine("Using FlattenHierarchy and invoking the PrintName
 method.");
            Console.WriteLine("---------------------------------------------------------");
            methInfo = obj.GetType().GetMethod("PrintName");
            methInfo.Invoke(obj,BindingFlags.FlattenHierarchy | 
                BindingFlags.InvokeMethod, null,new
 object[] 
                {"Brad","Smith"},null);
        }
    }

    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 ()
        {
            Name = "initialName";
        }

        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);
        }
    }
}

C++

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;

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";
      }

   }
   int methodCalled;
   TestClass()
   {
      Name = "initialName";
      array<Object^>^o = {(int^)0,1,2,3,4,5,6,7,8,9};
      values = o;
      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 );
   }

};

class Invoke
{
public:
   static void Go()
   {
      
      // BindingFlags::InvokeMethod
      // Call a static method.
      Type^ t = TestClass::typeid;
      Console::WriteLine();
      Console::WriteLine( "Invoking a static method."
 );
      Console::WriteLine( "-------------------------" );
      array<Object^>^obj1;
      t->InvokeMember( "SayHello", BindingFlags::InvokeMethod, nullptr,
 nullptr, obj1 );
      
      // 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, obj1 );
      c->GetType()->InvokeMember( "AddUp", BindingFlags::InvokeMethod,
 nullptr, c, obj1 );
      
      // 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, obj1 );
      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, obj1 );
      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, obj1 );
      Console::WriteLine( "Name == {0}", result );
      
      // BindingFlags::GetProperty
      result = t->InvokeMember( "Value", static_cast<BindingFlags>(BindingFlags::GetField
 | BindingFlags::GetProperty), nullptr, c, obj1 );
      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, obj1 );
      
      // BindingFlags::Static, NonPublic, and Public
      // Invoking a member by reference.
      Console::WriteLine();
      Console::WriteLine( "Invoking a method by reference." );
      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 ] );
      
      // The String* is case-sensitive.
      Type^ type = Type::GetType( "System.String" );
      
      // Check to see if the value is valid. If the Object* is 0, the
 type does not exist.
      if ( type == nullptr )
      {
         Console::WriteLine( "Please ensure that you specify only valid types
 in the type field." );
         Console::WriteLine( "The type name is case-sensitive."
 );
         return;
      }

      
      // Declare and populate the arrays to hold the information.
      // You must declare either NonPublic or Public with Static or
 the search will not work.
      array<FieldInfo^>^fi = type->GetFields( static_cast<BindingFlags>(BindingFlags::Static
 | BindingFlags::NonPublic | BindingFlags::Public) );
      
      // BindingFlags::NonPublic 
      array<MethodInfo^>^miNonPublic = type->GetMethods( static_cast<BindingFlags>(BindingFlags::Static
 | BindingFlags::NonPublic) );
      
      // BindingFlags::Public
      array<MethodInfo^>^miPublic = type->GetMethods( static_cast<BindingFlags>(BindingFlags::Static
 | BindingFlags::Public) );
      
      // Iterate through all the nonpublic methods.
      IEnumerator^ myEnum1 = miNonPublic->GetEnumerator();
      while ( myEnum1->MoveNext() )
      {
         MethodInfo^ method = safe_cast<MethodInfo^>(myEnum1->Current);
         Console::WriteLine( method );
      }

      IEnumerator^ myEnum2 = miPublic->GetEnumerator();
      while ( myEnum2->MoveNext() )
      {
         MethodInfo^ method = safe_cast<MethodInfo^>(myEnum2->Current);
         Console::WriteLine( method );
      }

      IEnumerator^ myEnum3 = fi->GetEnumerator();
      while ( myEnum3->MoveNext() )
      {
         FieldInfo^ f = safe_cast<FieldInfo^>(myEnum3->Current);
         Console::WriteLine( f );
      }

      
      // BindingFlags::Instance
      // Call an instance method.
      TestClass^ tc = gcnew TestClass;
      Console::WriteLine();
      Console::WriteLine( "Invoking an Instance method." );
      Console::WriteLine( "----------------------------" );
      tc->GetType()->InvokeMember( "AddUp", static_cast<BindingFlags>(BindingFlags::Public
 | BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, tc, obj1 );
      
      // BindingFlags::CreateInstance
      // Calling and creating an instance method.
      Console::WriteLine();
      Console::WriteLine( "Invoking and creating an instance method." );
      Console::WriteLine( "-----------------------------------------" );
      tc->GetType()->InvokeMember( "AddUp", static_cast<BindingFlags>(BindingFlags::Public
 | BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, tc, obj1 );
      
      // BindingFlags::DeclaredOnly
      TestClass^ tc2 = gcnew TestClass;
      Console::WriteLine();
      Console::WriteLine( "DeclaredOnly members" );
      Console::WriteLine( "---------------------------------" );
      array<System::Reflection::MemberInfo^>^memInfo = tc2->GetType()->GetMembers(
 BindingFlags::DeclaredOnly );
      for ( int i = 0; i < memInfo->Length;
 i++ )
      {
         Console::WriteLine( memInfo[ i ]->Name );

      }
      
      // BindingFlags::SuppressChangeType
      TestClass^ obj = gcnew TestClass;
      Console::WriteLine();
      Console::WriteLine( "Invoking static method - PrintName"
 );
      Console::WriteLine( "---------------------------------" );
      System::Reflection::MethodInfo^ methInfo = obj->GetType()->GetMethod(
 "PrintName" );
      array<Object^>^args1 = {"Brad","Smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::SuppressChangeType
 | BindingFlags::InvokeMethod), nullptr, args1, nullptr );
      
      // BindingFlags::IgnoreCase
      Console::WriteLine();
      Console::WriteLine( "Using IgnoreCase and invoking the PrintName method."
 );
      Console::WriteLine( "---------------------------------------------------"
 );
      methInfo = obj->GetType()->GetMethod( "PrintName" );
      array<Object^>^args2 = {"brad","smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::IgnoreCase
 | BindingFlags::InvokeMethod), nullptr, args2, nullptr );
      
      // BindingFlags::IgnoreReturn
      Console::WriteLine();
      Console::WriteLine( "Using IgnoreReturn and invoking the PrintName method."
 );
      Console::WriteLine( "-----------------------------------------------------"
 );
      methInfo = obj->GetType()->GetMethod( "PrintName" );
      array<Object^>^args3 = {"Brad","Smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::IgnoreReturn
 | BindingFlags::InvokeMethod), nullptr, args3, nullptr );
      
      // BindingFlags::OptionalParamBinding
      Console::WriteLine();
      Console::WriteLine( "Using OptionalParamBinding and invoking the PrintName
 method." );
      Console::WriteLine( "-------------------------------------------------------------"
 );
      methInfo = obj->GetType()->GetMethod( "PrintName" );
      array<Object^>^args4 = {"Brad","Smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::OptionalParamBinding
 | BindingFlags::InvokeMethod), nullptr, args4, nullptr );
      
      // BindingFlags::ExactBinding
      Console::WriteLine();
      Console::WriteLine( "Using ExactBinding and invoking the PrintName method."
 );
      Console::WriteLine( "-----------------------------------------------------"
 );
      methInfo = obj->GetType()->GetMethod( "PrintName" );
      array<Object^>^args5 = {"Brad","Smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::ExactBinding
 | BindingFlags::InvokeMethod), nullptr, args5, nullptr );
      
      // BindingFlags::FlattenHierarchy
      Console::WriteLine();
      Console::WriteLine( "Using FlattenHierarchy and invoking the PrintName
 method." );
      Console::WriteLine( "---------------------------------------------------------"
 );
      methInfo = obj->GetType()->GetMethod( "PrintName" );
      array<Object^>^args6 = {"Brad","Smith"};
      methInfo->Invoke( obj, static_cast<BindingFlags>(BindingFlags::FlattenHierarchy
 | BindingFlags::InvokeMethod), nullptr, args6, nullptr );
   }

};

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   Invoke::Go();
}

//}

package BindingFlagsSnippet; 

import System.*;
import System.Reflection.*;
import System.IO.*;
   
class EntryPoint
{
    public static void main(String[]
 args)
    {
        Invoke.Go();
    } //main
} //EntryPoint
   
class Invoke
{
    public static void Go()
    {
        // BindingFlags.InvokeMethod
        // Call a static method.
        Type t = TestClass.class.ToType();

        Console.WriteLine();
        Console.WriteLine("Invoking a static method.");
        Console.WriteLine("-------------------------");
        t.InvokeMember("SayHello", BindingFlags.InvokeMethod, 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[] { (System.Double)100.09,
 
            (System.Double)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[] { (Int32)index });
        Console.WriteLine("Item[{0}] == {1}", (Int32)index, result);

        // BindingFlags.SetProperty
        // Set an indexed property value.
        index = 3;
        t.InvokeMember("Item", BindingFlags.SetProperty, null,
 c, 
            new Object[] { (Int32)index, "NewValue"
 });
        result = t.InvokeMember("Item", BindingFlags.GetProperty, null,
 c, 
            new Object[] { (Int32)index });
        Console.WriteLine("Item[{0}] == {1}", (Int32)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 = TestClass2.class.ToType();
        t3.InvokeMember("", BindingFlags.InvokeMethod | BindingFlags.Default,
 
            null, new TestClass2(), new
 Object[]{});

        // BindingFlags.Static, NonPublic, and Public
        // Invoking a member by reference.
        Console.WriteLine();
        Console.WriteLine("Invoking a method by reference.");
        Console.WriteLine("-------------------------------");

        MethodInfo m = t.GetMethod("Swap");

        args = new Object[2];
        args[0] = (Int32)1;
        args[1] = (Int32)2;
        m.Invoke(new TestClass(), args);
        Console.WriteLine("{0}, {1}", args[0], args[1]);

        // The string is case-sensitive.
        Type type = Type.GetType("System.String");

        // Check to see if the value is valid. If the object is null,
 
        // the type does not exist.
        if (type == null) {
            Console.WriteLine("Please ensure that you specify only valid types
 "
                + "in the type field.");
            Console.WriteLine("The type name is case-sensitive.");
            return;
        }

        // Declare and populate the arrays to hold the information.
        // You must declare either NonPublic or Public with Static or
 the 
        // search will not work.
        FieldInfo fi[] = type.GetFields(
            BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);

        // BindingFlags.NonPublic 
        MethodInfo miNonPublic[] = type.GetMethods(
            BindingFlags.Static | BindingFlags.NonPublic);

        // BindingFlags.Public
        MethodInfo miPublic[] = type.GetMethods(
            BindingFlags.Static | BindingFlags.Public);

        // Iterate through all the nonpublic methods.
        for (int iCtr = 0; iCtr < miNonPublic.length;
 iCtr++) {
            MethodInfo method = (MethodInfo)miNonPublic.get_Item(iCtr);
            Console.WriteLine(method);
        }

        // Iterate through all the public methods.
        for (int iCtr = 0; iCtr < miPublic.length;
 iCtr++) {
            MethodInfo method = (MethodInfo)miPublic.get_Item(iCtr);
            Console.WriteLine(method);
        }

        // Iterate through all the fields.
        for (int iCtr = 0; iCtr < fi.length;
 iCtr++) {
            FieldInfo f = (FieldInfo)fi.get_Item(iCtr);
            Console.WriteLine(f);
        }

        // BindingFlags.Instance
        // Call an instance method.
        TestClass tc = new TestClass();

        Console.WriteLine();
        Console.WriteLine("Invoking an Instance method.");
        Console.WriteLine("----------------------------");
        tc.GetType().InvokeMember("AddUp", BindingFlags.Public 
            | BindingFlags.Instance | BindingFlags.CreateInstance, null,
 tc, 
            new Object[]{});

        // BindingFlags.CreateInstance
        // Calling and creating an instance method.
        Console.WriteLine();
        Console.WriteLine("Invoking and creating an instance method.");
        Console.WriteLine("-----------------------------------------");
        tc.GetType().InvokeMember("AddUp", BindingFlags.Public 
            | BindingFlags.Instance | BindingFlags.CreateInstance, null,
 tc, 
            new Object[]{});

        // BindingFlags.DeclaredOnly
        TestClass tc2 = new TestClass();

        Console.WriteLine();
        Console.WriteLine("DeclaredOnly members");
        Console.WriteLine("---------------------------------");

        System.Reflection.MemberInfo memInfo[] = tc2.GetType().
            GetMembers(BindingFlags.DeclaredOnly);
        for (int i = 0; i < memInfo.length;
 i++) {
            Console.WriteLine(((System.Reflection.MemberInfo)memInfo.
                get_Item(i)).get_Name());
        }

        // BindingFlags.SuppressChangeType
        TestClass obj = new TestClass();

        Console.WriteLine();
        Console.WriteLine("Invoking static method - PrintName");
        Console.WriteLine("---------------------------------");
        System.Reflection.MethodInfo methInfo = obj.GetType().
            GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.SuppressChangeType | BindingFlags.InvokeMethod, null,
 
            new Object[] { "Brad", "Smith"
 }, null);

        // BindingFlags.IgnoreCase
        Console.WriteLine();
        Console.WriteLine("Using IgnoreCase and invoking the PrintName method.");
        Console.WriteLine("---------------------------------------------------");
        methInfo = obj.GetType().GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.IgnoreCase | BindingFlags.InvokeMethod, null,
 
            new Object[] { "brad", "smith"
 }, null);

        // BindingFlags.IgnoreReturn
        Console.WriteLine();
        Console.WriteLine("Using IgnoreReturn and invoking the PrintName "
            + "method.");
        Console.WriteLine("----------------------------------------------"
            + "-------");
        methInfo = obj.GetType().GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.IgnoreReturn | BindingFlags.InvokeMethod, null,
 
            new Object[] { "Brad", "Smith"
 }, null);

        // BindingFlags.OptionalParamBinding
        Console.WriteLine();
        Console.WriteLine("Using OptionalParamBinding and invoking the "
            + "PrintName method.");
        Console.WriteLine("-------------------------------------------------"
            + "------------");
        methInfo = obj.GetType().GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.OptionalParamBinding | BindingFlags.InvokeMethod, 
            null, new Object[] { "Brad",
 "Smith" }, null);

        // BindingFlags.ExactBinding
        Console.WriteLine();
        Console.WriteLine("Using ExactBinding and invoking the PrintName "
            + "method.");
        Console.WriteLine("-------------------------------------------------"
            + "----");
        methInfo = obj.GetType().GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.ExactBinding | BindingFlags.InvokeMethod, null,
 
            new Object[] { "Brad", "Smith"
 }, null);

        // BindingFlags.FlattenHierarchy
        Console.WriteLine();
        Console.WriteLine("Using FlattenHierarchy and invoking the PrintName
 "
            + "method.");
        Console.WriteLine("---------------------------------------------------"
            + "------");
        methInfo = obj.GetType().GetMethod("PrintName");
        methInfo.Invoke(obj, 
            BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod, null,
 
            new Object[] { "Brad", "Smith"
 }, null);
    } //Go
} //Invoke
      
public class TestClass
{
    public String name;
    private Object values[] = new Object[]
 { (Int32)0, (Int32)1, (Int32)2, 
        (Int32)3, (Int32)4, (Int32)5, (Int32)6, (Int32)7, (Int32)8, (Int32)9 };

    /** @property 
     */
    public Object get_Item(int index)
    {
        return values.get_Item(index);
    } //get_Item

    /** @property 
     */
    public void set_Item(int
 index, Object value)
    {
        values.set_Item(index, value);
    } //set_Item

    /** @property 
     */
    public Object get_Value()
    {
        return "the value";
    } //get_Value

    public TestClass()
    {
        name = "initialName";
    } //TestClass

    private int methodCalled = 0;

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

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

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

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

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

    public void Swap(int
 a, int b)
    {
        int x = a;
        a = b;
        b = x;
    } //Swap
} //TestClass 
   
/** @attribute DefaultMemberAttribute("PrintTime")
 */
 public class TestClass2
 {
     public void PrintTime()
     {
         Console.WriteLine(DateTime.get_Now());
     } //PrintTime
 } //TestClass2