이 설명서는 보관되지만 유지 되지 않습니다.

BindingFlags 열거형

업데이트: 2007년 11월

리플렉션에서 멤버 및 형식 검색이 수행되는 방식과 바인딩을 제어하는 플래그를 지정합니다.

이 열거형에는 멤버 값을 비트로 조합할 수 있는 FlagsAttribute 특성이 있습니다.

네임스페이스:  System.Reflection
어셈블리:  mscorlib(mscorlib.dll)

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

멤버 이름설명
Default바인딩 플래그를 지정하지 않습니다.
IgnoreCase바인딩할 때 멤버 이름의 대/소문자를 구분하지 않도록 지정합니다.
DeclaredOnly지정된 형식의 계층 구조 수준으로 선언된 멤버만 고려되도록 지정합니다. 상속된 멤버는 고려되지 않습니다.
Instance인스턴스 멤버를 검색에 포함시키도록 지정합니다.
Static정적 멤버를 검색에 포함시키도록 지정합니다.
Public공용 멤버를 검색에 포함시키도록 지정합니다.
NonPublic비공용 멤버를 검색에 포함시키도록 지정합니다.
FlattenHierarchy계층 구조 위쪽의 공용 및 보호되는 정적 멤버가 반환되도록 지정합니다. 상속된 클래스의 전용 정적 멤버는 반환되지 않습니다. 정적 멤버에는 필드, 메서드, 이벤트, 속성이 있습니다. 중첩된 형식은 반환되지 않습니다.
InvokeMethod메서드를 불러오도록 지정합니다. 이는 생성자 또는 형식 이니셜라이저가 아니어야 합니다.
CreateInstance리플렉션에서 지정된 형식의 인스턴스를 만들도록 지정합니다. 주어진 인수에 해당하는 생성자를 호출합니다. 지정된 멤버 이름은 무시됩니다. 조회 형식이 지정되지 않은 경우 (인스턴스 | 형식 이니셜라이저는 호출할 수 없습니다.
GetField지정된 필드의 값이 반환되도록 지정합니다.
SetField지정된 필드의 값을 설정하도록 지정합니다.
GetProperty지정된 속성의 값이 반환되도록 지정합니다.
SetProperty지정된 속성의 값을 설정하도록 지정합니다. COM 속성의 경우 이 바인딩 플래그를 지정하는 것은 PutDispPropertyPutRefDispProperty를 지정하는 것과 같습니다.
PutDispPropertyCOM 개체의 PROPPUT 멤버를 불러오도록 지정합니다. PROPPUT은 값을 사용하는 속성 설정 함수를 지정합니다. 속성에 PROPPUTPROPPUTREF가 모두 있고 이 중에서 호출할 대상을 선택해야 하는 경우 PutDispProperty를 사용합니다.
PutRefDispPropertyCOM 개체의 PROPPUTREF 멤버를 불러오도록 지정합니다. PROPPUTREF는 값 대신 참조를 사용하는 속성 설정 함수를 지정합니다. 속성에 PROPPUTPROPPUTREF가 모두 있고 이 중에서 호출할 대상을 선택해야 하는 경우 PutRefDispProperty를 사용합니다.
ExactBinding지정된 인수의 형식이 대응하는 형식 매개 변수의 형식과 정확하게 일치하도록 지정합니다. 리플렉션에서는 호출자가 null이 아닌 Binder 개체를 제공하면 적합한 메서드를 선택하는 BindToXXX 구현을 제공하는 것이므로 예외를 throw합니다.
SuppressChangeType구현되지 않았습니다.
OptionalParamBinding매개 변수 개수가 지정된 인수의 개수와 일치하는 멤버 집합을 반환합니다. 이 바인딩 플래그는 기본값을 사용하는 매개 변수가 있는 메서드와 가변 인수(varargs)가 있는 메서드에 사용됩니다. 이 플래그는 Type.InvokeMember을 통해 사용해야만 합니다.
IgnoreReturnCOM interop에서 사용되어 멤버의 반환 값을 무시할 수 있도록 지정합니다.

이러한 BindingFlags는 멤버 및 형식을 불러오고 만들고 가져오고 설정하고 검색하는 System, System.ReflectionSystem.Runtime 네임스페이스에 있는 많은 클래스에 대한 바인딩을 제어합니다.

BindingFlags는 다음과 같은 Type 메서드와 MethodBase.Invoke 등에서 사용합니다.

InvokeMemberGetMethod는 특히 중요합니다.

다음 표에서 보여 주는 것처럼 형식 멤버를 식별하는 방식에 따라 바인딩 플래그를 분류할 수 있습니다.

액세스 가능성으로 식별

바인딩 인수로 식별

작업으로 식별

DeclaredOnly

FlattenHierarchy

IgnoreCase

IgnoreReturn

Instance

NonPublic

Public

Static

ExactBinding

OptionalParamBinding

CreateInstance

GetField

SetField

GetProperty

SetProperty

InvokeMethod

PutDispProperty

PutRefDispProperty

참고:

Instance 또는 StaticPublic 또는 NonPublic과 함께 지정해야 합니다. 그렇지 않으면 멤버가 반환되지 않습니다.

다음 표에서는 기본 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

비참조 형식

참조 형식

다음 예제에서는 각 바인딩 플래그를 보여 줍니다.

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 | BindingFlags.Public | BindingFlags.Static, null, null, new object [] {});

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

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

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

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

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

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

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

            // BindingFlags.Static, NonPublic, and Public
            // Invoking a member 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);
        }
    }
}


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 | BindingFlags.Public | BindingFlags.Static, null, null, 
            new Object[]{});

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

        // BindingFlags.InvokeMethod
        // Call a method with parameters.
        Object args[] = new Object[] { (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 Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360

.NET Framework 및 .NET Compact Framework에서 모든 플랫폼의 전체 버전을 지원하지는 않습니다. 지원되는 버전의 목록을 보려면 .NET Framework 시스템 요구 사항을 참조하십시오.

.NET Framework

3.5, 3.0, 2.0, 1.1, 1.0에서 지원

.NET Compact Framework

3.5, 2.0, 1.0에서 지원

XNA Framework

2.0, 1.0에서 지원
표시: