BindingFlags 枚举

指定控制绑定和由反射执行的成员和类型搜索方法的标志。

此枚举有一个 FlagsAttribute 属性，允许其成员值按位组合。

**命名空间:**System.Reflection
**程序集:**mscorlib（在 mscorlib.dll 中）

语法

声明
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<FlagsAttribute> _
Public Enumeration BindingFlags
用法
Dim instance As BindingFlags

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

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

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

SerializableAttribute 
ComVisibleAttribute(true) 
FlagsAttribute 
public enum BindingFlags

成员

	成员名称	说明
	CreateInstance	指定“反射”应该创建指定类型的实例。调用与给定参数匹配的构造函数。忽略提供的成员名。如果未指定查找类型，将应用 (Instance |Public)。调用类型初始值设定项是不可能的。
	DeclaredOnly	指定只应考虑在所提供类型的层次结构级别上声明的成员。不考虑继承成员。
	Default	不指定绑定标志。
	ExactBinding	指定提供参数的类型必须与对应形参的类型完全匹配。如果调用方提供一个非空 Binder 对象，则“反射”将引发异常，因为这意味着调用方正在提供的 BindToXXX 实现将选取适当的方法。  “反射”建立通用类型系统的可访问规则模型。例如，如果调用方在相同的程序集内，则它不需要内部成员的特殊权限。否则，调用方需要 ReflectionPermission。这与保护成员、私有成员等成员的查找是一致的。 一般原则是，ChangeType 应只执行永远不会丢失数据的扩展强制。扩展强制的一个例子是将 32 位有符号整数值强制为 64 位有符号整数值。这与窄缩强制不同，后者可能丢失数据。窄缩强制的一个例子是将 64 位有符号整数强制为 32 位有符号整数。 默认联编程序忽略此标志，而自定义联编程序可以实现此标志的语义。
	FlattenHierarchy	指定应返回层次结构上的公共静态成员和受保护的静态成员。不返回继承类中的私有静态成员。静态成员包括字段、方法、事件和属性。不返回嵌套类型。
	GetField	指定应返回指定字段的值。
	GetProperty	指定应返回指定属性的值。
	IgnoreCase	指定当绑定时不应考虑成员名的大小写。
	IgnoreReturn	在 COM interop 中用于指定可以忽略成员的返回值。
	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

提示

必须与 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
非引用	通过引用。

示例

下面的示例说明每个绑定标志。

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

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

平台

Windows 98、Windows 2000 SP4、Windows CE、Windows Millennium Edition、Windows Mobile for Pocket PC、Windows Mobile for Smartphone、Windows Server 2003、Windows XP Media Center Edition、Windows XP Professional x64 Edition、Windows XP SP2、Windows XP Starter Edition

.NET Framework 并不是对每个平台的所有版本都提供支持。有关受支持版本的列表，请参见系统要求。

版本信息

.NET Framework

受以下版本支持：2.0、1.1、1.0

.NET Compact Framework

受以下版本支持：2.0、1.0

请参见

参考

System.Reflection 命名空间