MethodBase.Invoke 메서드

정의

MethodInfo 인스턴스에 의해 리플렉션된 메서드나 생성자를 호출합니다.Invokes the method or constructor reflected by this MethodInfo instance.

오버로드

Invoke(Object, Object[])

지정된 매개 변수를 사용하여 현재 인스턴스로 나타낸 메서드 또는 생성자를 호출합니다.Invokes the method or constructor represented by the current instance, using the specified parameters.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

파생 클래스에서 재정의된 경우, 지정된 매개 변수를 사용하여 리플렉션된 메서드나 생성자를 호출합니다.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

Invoke(Object, Object[])

지정된 매개 변수를 사용하여 현재 인스턴스로 나타낸 메서드 또는 생성자를 호출합니다.Invokes the method or constructor represented by the current instance, using the specified parameters.

public:
 System::Object ^ Invoke(System::Object ^ obj, cli::array <System::Object ^> ^ parameters);
public object Invoke (object obj, object[] parameters);
member this.Invoke : obj * obj[] -> obj
Public Function Invoke (obj As Object, parameters As Object()) As Object

매개 변수

obj
Object

메서드 또는 생성자를 호출할 개체입니다.The object on which to invoke the method or constructor. 메서드가 static이면 이 인수는 무시됩니다.If a method is static, this argument is ignored. 생성자가 static이면 이 인수는 null 또는 생성자를 정의하는 클래스의 인스턴스여야 합니다.If a constructor is static, this argument must be null or an instance of the class that defines the constructor.

parameters
Object[]

호출된 메서드 또는 생성자에 대한 인수 목록입니다.An argument list for the invoked method or constructor. 호출되는 메서드 또는 생성자의 매개 변수와 개수, 순서, 형식이 동일한 개체의 배열입니다.This is an array of objects with the same number, order, and type as the parameters of the method or constructor to be invoked. 매개 변수가 없는 경우 parametersnull이어야 합니다.If there are no parameters, parameters should be null.

이 인스턴스로 나타내는 메서드 또는 생성자가 ref 매개 변수(Visual Basic의 ByRef)를 사용하는 경우 이 함수를 사용하여 메서드 또는 생성자를 호출하기 위해 해당 매개 변수에 특별한 특성이 필요하지 않습니다.If the method or constructor represented by this instance takes a ref parameter (ByRef in Visual Basic), no special attribute is required for that parameter in order to invoke the method or constructor using this function. 값으로 명시적으로 초기화되지 않은 이 배열의 모든 개체는 해당 개체 형식에 대해 기본값을 포함합니다.Any object in this array that is not explicitly initialized with a value will contain the default value for that object type. 참조 형식 요소의 경우 이 값은 null입니다.For reference-type elements, this value is null. 값 형식 요소의 경우 이 값은 특정 요소 형식에 따라 0, 0.0 또는 false입니다.For value-type elements, this value is 0, 0.0, or false, depending on the specific element type.

반환

호출된 메서드의 반환 값을 포함하는 개체이거나 생성자의 경우는 null입니다.An object containing the return value of the invoked method, or null in the case of a constructor.

구현

예외

Windows 스토어 앱용 .NET 또는 이식 가능한 클래스 라이브러리에서 대신 Exception을 catch합니다.In the.NET for Windows Store apps or the Portable Class Library, catch Exception instead.

obj 매개 변수가 null이고 메서드가 static이 아닌 경우The obj parameter is null and the method is not static. 또는-or- 메서드가 obj 클래스에서 선언되지도 않고 상속되지도 않은 경우The method is not declared or inherited by the class of obj. 또는-or- static 생성자가 호출되고 objnull도 아니고 생성자를 선언한 클래스의 인스턴스도 아닌 경우A static constructor is invoked, and obj is neither null nor an instance of the class that declared the constructor.

parameters 배열의 요소가 이 인스턴스에서 리플렉트된 메서드 또는 생성자의 시그니처와 일치하지 않는 경우The elements of the parameters array do not match the signature of the method or constructor reflected by this instance.

호출된 메서드 또는 생성자가 예외를 throw하는 경우The invoked method or constructor throws an exception.

또는-or- 현재 인스턴스가 확인할 수 없는 코드를 포함하는 DynamicMethod인 경우The current instance is a DynamicMethod that contains unverifiable code. DynamicMethod에 대한 설명에서 "확인" 섹션을 참조하세요.See the "Verification" section in Remarks for DynamicMethod.

parameters 배열에 올바른 수의 인수가 포함되어 있지 않은 경우The parameters array does not have the correct number of arguments.

Windows 스토어 앱용 .NET 또는 이식 가능한 클래스 라이브러리에서 대신 기본 클래스 예외 MemberAccessException을 catch합니다.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, MemberAccessException, instead.

호출자에 현재 인스턴스로 나타내는 메서드 또는 생성자를 실행할 수 있는 권한이 없습니다.The caller does not have permission to execute the method or constructor that is represented by the current instance.

이 메서드를 선언하는 형식이 오픈 제네릭 형식입니다.The type that declares the method is an open generic type. 즉, ContainsGenericParameters 속성이 선언 형식에 대해 true를 반환합니다.That is, the ContainsGenericParameters property returns true for the declaring type.

현재 인스턴스는 MethodBuilder입니다.The current instance is a MethodBuilder.

예제

다음 코드 예제에서는 리플렉션을 사용 하 여 동적 메서드 조회 하는 방법을 보여 줍니다.The following code example demonstrates dynamic method lookup using reflection. 사용할 수 없습니다는 MethodInfo 런타임에 바인딩을 재정의 확인할 수 없습니다 때문에 파생된 클래스에서 재정의 된 메서드를 호출 하는 기본 클래스에서 개체입니다.Note that you cannot use the MethodInfo object from the base class to invoke the overridden method in the derived class, because late binding cannot resolve overrides.

using namespace System;
using namespace System::Reflection;

public ref class MagicClass
{
private:
    int magicBaseValue;

public:
    MagicClass()
    {
        magicBaseValue = 9;
    }

    int ItsMagic(int preMagic)
    {
        return preMagic * magicBaseValue;
    }
};

public ref class TestMethodInfo
{
public:
    static void Main()
    {
        // Get the constructor and create an instance of MagicClass

        Type^ magicType = Type::GetType("MagicClass");
        ConstructorInfo^ magicConstructor = magicType->GetConstructor(Type::EmptyTypes);
        Object^ magicClassObject = magicConstructor->Invoke(gcnew array<Object^>(0));

        // Get the ItsMagic method and invoke with a parameter value of 100

        MethodInfo^ magicMethod = magicType->GetMethod("ItsMagic");
        Object^ magicValue = magicMethod->Invoke(magicClassObject, gcnew array<Object^>(1){100});

        Console::WriteLine("MethodInfo.Invoke() Example\n");
        Console::WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
    }
};

int main()
{
    TestMethodInfo::Main();
}

// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900
using System;
using System.Reflection;

public class MagicClass
{
    private int magicBaseValue;

    public MagicClass()
    {
        magicBaseValue = 9;
    }
    
    public int ItsMagic(int preMagic)
    {
        return preMagic * magicBaseValue;
    }
}

public class TestMethodInfo
{
    public static void Main()
    {
        // Get the constructor and create an instance of MagicClass

        Type magicType = Type.GetType("MagicClass");
        ConstructorInfo magicConstructor = magicType.GetConstructor(Type.EmptyTypes);
        object magicClassObject = magicConstructor.Invoke(new object[]{});

        // Get the ItsMagic method and invoke with a parameter value of 100

        MethodInfo magicMethod = magicType.GetMethod("ItsMagic");
        object magicValue = magicMethod.Invoke(magicClassObject, new object[]{100});

        Console.WriteLine("MethodInfo.Invoke() Example\n");
        Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue);
    }
}

// The example program gives the following output:
//
// MethodInfo.Invoke() Example
//
// MagicClass.ItsMagic() returned: 900
Imports System.Reflection

Public Class MagicClass
    Private magicBaseValue As Integer

    Public Sub New()
        magicBaseValue = 9
    End Sub

    Public Function ItsMagic(preMagic As Integer) As Integer
        Return preMagic * magicBaseValue
    End Function
End Class

Public Class TestMethodInfo
    Public Shared Sub Main()
        ' Get the constructor and create an instance of MagicClass

        Dim magicType As Type = Type.GetType("MagicClass")
        Dim magicConstructor As ConstructorInfo = magicType.GetConstructor(Type.EmptyTypes)
        Dim magicClassObject As Object = magicConstructor.Invoke(New Object(){})

        ' Get the ItsMagic method and invoke with a parameter value of 100

        Dim magicMethod As MethodInfo = magicType.GetMethod("ItsMagic")
        Dim magicValue As Object = magicMethod.Invoke(magicClassObject, New Object(){100})

        Console.WriteLine("MethodInfo.Invoke() Example" + vbNewLine)
        Console.WriteLine("MagicClass.ItsMagic() returned: {0}", magicValue)
    End Sub
End Class

' The example program gives the following output:
'
' MethodInfo.Invoke() Example
'
' MagicClass.ItsMagic() returned: 900

설명

이 호출 하는 편의 메서드를 Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) 메서드 오버 로드를 전달 Default 에 대 한 invokeAttrnull 에 대 한 binderculture.This is a convenience method that calls the Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) method overload, passing Default for invokeAttr and null for binder and culture.

호출 된 메서드가 예외를 throw 하는 경우는 Exception.GetBaseException 메서드 예외를 반환 합니다.If the invoked method throws an exception, the Exception.GetBaseException method returns the exception.

사용 하 여 정적 메서드를 호출 하려면 해당 MethodInfo 개체를 전달 null 에 대 한 obj합니다.To invoke a static method using its MethodInfo object, pass null for obj.

참고

이 메서드 오버 로드 인스턴스 생성자 호출을 사용 하는 경우에 대 한 제공 된 개체가 obj 다시 초기화 됩니다; 즉, 모든 인스턴스 이니셜라이저 실행 됩니다.If this method overload is used to invoke an instance constructor, the object supplied for obj is reinitialized; that is, all instance initializers are executed. 반환 값은 null입니다.The return value is null. 클래스 생성자를 호출 하는 경우 클래스를 다시 초기화 됩니다. 즉, 모든 클래스 이니셜라이저가 실행 됩니다.If a class constructor is invoked, the class is reinitialized; that is, all class initializers are executed. 반환 값은 null입니다.The return value is null.

참고

부터 합니다 .NET Framework 2.0 서비스 팩 1.NET Framework 2.0 Service Pack 1,이 메서드를 사용 하 여 호출자에 게 부여 된 경우 public이 아닌 멤버에 액세스할 수 있습니다 ReflectionPermission 사용 하 여는 ReflectionPermissionFlag.RestrictedMemberAccess 플래그 및 public이 아닌 멤버의 권한 부여 집합 호출자 에게만 부여 된 집합 또는 하위 집합 그 합니다.Starting with the .NET Framework 2.0 서비스 팩 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public members if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public members is restricted to the caller's grant set, or a subset thereof. (참조 리플렉션의 보안 고려 사항.)(See Security Considerations for Reflection.)

이 기능을 사용하려면 애플리케이션이 .NET Framework 3.5.NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

현재 메서드의 매개 변수 값 형식 및 해당 인수 이면 parametersnull, 런타임에 값 형식의 0으로 초기화 된 인스턴스를 전달 합니다.If a parameter of the current method is a value type, and the corresponding argument in parameters is null, the runtime passes a zero-initialized instance of the value type.

보안

ReflectionPermission
호출 될 때 런타임에 바인딩된 메커니즘을 통해 같은 InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])합니다.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). 연관된 열거형: MemberAccessAssociated enumeration: MemberAccess.

추가 정보

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

파생 클래스에서 재정의된 경우, 지정된 매개 변수를 사용하여 리플렉션된 메서드나 생성자를 호출합니다.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

public:
 abstract System::Object ^ Invoke(System::Object ^ obj, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ parameters, System::Globalization::CultureInfo ^ culture);
public abstract object Invoke (object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);
abstract member Invoke : obj * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo -> obj

매개 변수

obj
Object

메서드 또는 생성자를 호출할 개체입니다.The object on which to invoke the method or constructor. 메서드가 static이면 이 인수는 무시됩니다.If a method is static, this argument is ignored. 생성자가 static이면 이 인수는 null 또는 생성자를 정의하는 클래스의 인스턴스여야 합니다.If a constructor is static, this argument must be null or an instance of the class that defines the constructor.

invokeAttr
BindingFlags

BindingFlags의 비트 플래그 0개 이상으로 조합된 비트 마스크입니다.A bitmask that is a combination of 0 or more bit flags from BindingFlags. bindernull이면 이 매개 변수에는 값 Default가 할당됩니다. 따라서, 전달되는 모든 값은 무시됩니다.If binder is null, this parameter is assigned the value Default; thus, whatever you pass in is ignored.

binder
Binder

리플렉션을 사용하여 바인딩, 인수 형식의 강제 변환, 멤버 호출 및 MemberInfo 개체 검색을 사용할 수 있도록 하는 개체입니다.An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects via reflection. bindernull이면 기본 바인더가 사용됩니다.If binder is null, the default binder is used.

parameters
Object[]

호출된 메서드 또는 생성자에 대한 인수 목록입니다.An argument list for the invoked method or constructor. 호출되는 메서드 또는 생성자의 매개 변수와 개수, 순서, 형식이 동일한 개체의 배열입니다.This is an array of objects with the same number, order, and type as the parameters of the method or constructor to be invoked. 이 목록은 매개 변수가 없으면 null이어야 합니다.If there are no parameters, this should be null.

이 인스턴스가 나타내는 메서드나 생성자에 ByRef 매개 변수가 있으면 해당 매개 변수에 특수한 특성이 없어도 이 함수를 사용하여 메서드나 생성자를 호출할 수 있습니다.If the method or constructor represented by this instance takes a ByRef parameter, there is no special attribute required for that parameter in order to invoke the method or constructor using this function. 값으로 명시적으로 초기화되지 않은 이 배열의 모든 개체는 해당 개체 형식에 대해 기본값을 포함합니다.Any object in this array that is not explicitly initialized with a value will contain the default value for that object type. 참조 형식 요소의 경우 이 값은 null입니다.For reference-type elements, this value is null. 값 형식 요소의 경우 이 값은 특정 요소 형식에 따라 0, 0.0 또는 false입니다.For value-type elements, this value is 0, 0.0, or false, depending on the specific element type.

culture
CultureInfo

형식의 강제 변환을 제어하는 데 사용되는 CultureInfo의 인스턴스입니다.An instance of CultureInfo used to govern the coercion of types. 이 매개 변수가 null이면 현재 스레드에 대한 CultureInfo가 사용됩니다.If this is null, the CultureInfo for the current thread is used. 예를 들어 1,000은 각 문화권마다 다르게 표현되므로 1,000을 나타내는 StringDouble 값으로 변환하기 위해 이 매개 변수가 필요합니다.(This is necessary to convert a String that represents 1000 to a Double value, for example, since 1000 is represented differently by different cultures.)

반환

호출된 메서드의 반환 값이 포함된 Object이거나, 생성자일 경우 null이거나, 메서드의 반환 형식이 null인 경우 void입니다.An Object containing the return value of the invoked method, or null in the case of a constructor, or null if the method's return type is void. 이 메서드나 생성자를 호출하기 전에 Invoke는 사용자에게 액세스 권한이 있는지 확인한 다음 매개 변수가 올바른지 검사합니다.Before calling the method or constructor, Invoke checks to see if the user has access permission and verifies that the parameters are valid.

구현

예외

obj 매개 변수가 null이고 메서드가 static이 아닌 경우The obj parameter is null and the method is not static.

또는-or- 메서드가 obj 클래스에서 선언되지도 않고 상속되지도 않은 경우The method is not declared or inherited by the class of obj.

또는-or- static 생성자가 호출되고 objnull도 아니고 생성자를 선언한 클래스의 인스턴스도 아닌 경우A static constructor is invoked, and obj is neither null nor an instance of the class that declared the constructor.

parameters 매개 변수의 형식이 이 인스턴스에 의해 리플렉션된 메서드 또는 생성자의 시그니처와 일치하지 않는 경우The type of the parameters parameter does not match the signature of the method or constructor reflected by this instance.

parameters 배열에 올바른 수의 인수가 포함되어 있지 않은 경우The parameters array does not have the correct number of arguments.

호출된 메서드 또는 생성자가 예외를 throw하는 경우The invoked method or constructor throws an exception.

호출자에 현재 인스턴스로 나타내는 메서드 또는 생성자를 실행할 수 있는 권한이 없습니다.The caller does not have permission to execute the method or constructor that is represented by the current instance.

이 메서드를 선언하는 형식이 오픈 제네릭 형식입니다.The type that declares the method is an open generic type. 즉, ContainsGenericParameters 속성이 선언 형식에 대해 true를 반환합니다.That is, the ContainsGenericParameters property returns true for the declaring type.

예제

다음 예제에서는 모든 멤버를 System.Reflection.Binder 오버 로드를 사용 하 여 클래스 Type.InvokeMember합니다.The following example demonstrates all members of the System.Reflection.Binder class using an overload of Type.InvokeMember. Private 메서드 CanConvertFrom 지정된 된 형식에 대 한 호환 되는 형식을 찾습니다.The private method CanConvertFrom finds compatible types for a given type. 사용자 지정 바인딩 시나리오에서 호출 멤버의 다른 예제를 보려면 를 사용 하 여 형식 동적 로드 및합니다.For another example of invoking members in a custom binding scenario, see Dynamically Loading and Using Types.

using namespace System;
using namespace System::Reflection;
using namespace System::Globalization;
using namespace System::Runtime::InteropServices;
public ref class MyBinder: public Binder
{
public:
   MyBinder()
      : Binder()
   {}

private:
   ref class BinderState
   {
   public:
      array<Object^>^args;
   };

public:
   virtual FieldInfo^ BindToField( BindingFlags bindingAttr, array<FieldInfo^>^match, Object^ value, CultureInfo^ culture ) override
   {
      if ( match == nullptr )
            throw gcnew ArgumentNullException( "match" );

      // Get a field for which the value parameter can be converted to the specified field type.
      for ( int i = 0; i < match->Length; i++ )
         if ( ChangeType( value, match[ i ]->FieldType, culture ) != nullptr )
                  return match[ i ];

      return nullptr;
   }

   virtual MethodBase^ BindToMethod( BindingFlags bindingAttr, array<MethodBase^>^match, array<Object^>^%args, array<ParameterModifier>^ modifiers, CultureInfo^ culture, array<String^>^names, [Out]Object^% state ) override
   {
      // Store the arguments to the method in a state Object*.
      BinderState^ myBinderState = gcnew BinderState;
      array<Object^>^arguments = gcnew array<Object^>(args->Length);
      args->CopyTo( arguments, 0 );
      myBinderState->args = arguments;
      state = myBinderState;
      if ( match == nullptr )
            throw gcnew ArgumentNullException;

      // Find a method that has the same parameters as those of the args parameter.
      for ( int i = 0; i < match->Length; i++ )
      {
         // Count the number of parameters that match.
         int count = 0;
         array<ParameterInfo^>^parameters = match[ i ]->GetParameters();

         // Go on to the next method if the number of parameters do not match.
         if ( args->Length != parameters->Length )
                  continue;

         // Match each of the parameters that the user expects the method to have.
         for ( int j = 0; j < args->Length; j++ )
         {
            // If the names parameter is not 0, then reorder args.
            if ( names != nullptr )
            {
               if ( names->Length != args->Length )
                              throw gcnew ArgumentException( "names and args must have the same number of elements." );

               for ( int k = 0; k < names->Length; k++ )
                  if ( String::Compare( parameters[ j ]->Name, names[ k ] ) == 0 )
                                    args[ j ] = myBinderState->args[ k ];
            }

            // Determine whether the types specified by the user can be converted to the parameter type.
            if ( ChangeType( args[ j ], parameters[ j ]->ParameterType, culture ) != nullptr )
                        count += 1;
            else
                        break;
         }
         if ( count == args->Length )
                  return match[ i ];
      }
      return nullptr;
   }

   virtual Object^ ChangeType( Object^ value, Type^ myChangeType, CultureInfo^ culture ) override
   {
      // Determine whether the value parameter can be converted to a value of type myType.
      if ( CanConvertFrom( value->GetType(), myChangeType ) )
         // Return the converted Object*.
         return Convert::ChangeType( value, myChangeType ); 
      else
         return nullptr;
   }

   virtual void ReorderArgumentArray( array<Object^>^%args, Object^ state ) override
   {
      // Return the args that had been reordered by BindToMethod.
      (safe_cast<BinderState^>(state))->args->CopyTo( args, 0 );
   }

   virtual MethodBase^ SelectMethod( BindingFlags bindingAttr, array<MethodBase^>^match, array<Type^>^types, array<ParameterModifier>^ modifiers ) override
   {
      if ( match == nullptr )
            throw gcnew ArgumentNullException( "match" );

      for ( int i = 0; i < match->Length; i++ )
      {
         // Count the number of parameters that match.
         int count = 0;
         array<ParameterInfo^>^parameters = match[ i ]->GetParameters();

         // Go on to the next method if the number of parameters do not match.
         if ( types->Length != parameters->Length )
                  continue;

         // Match each of the parameters that the user expects the method to have.
         for ( int j = 0; j < types->Length; j++ )
         {
            // Determine whether the types specified by the user can be converted to parameter type.
            if ( CanConvertFrom( types[ j ], parameters[ j ]->ParameterType ) )
                        count += 1;
            else
                        break;
         }
         // Determine whether the method has been found.
         if ( count == types->Length )
                  return match[ i ];
      }
      return nullptr;
   }

   virtual PropertyInfo^ SelectProperty( BindingFlags bindingAttr, array<PropertyInfo^>^match, Type^ returnType, array<Type^>^indexes, array<ParameterModifier>^ modifiers ) override
   {
      if ( match == nullptr )
            throw gcnew ArgumentNullException( "match" );

      for ( int i = 0; i < match->Length; i++ )
      {
         // Count the number of indexes that match.
         int count = 0;
         array<ParameterInfo^>^parameters = match[ i ]->GetIndexParameters();

         // Go on to the next property if the number of indexes do not match.
         if ( indexes->Length != parameters->Length )
                  continue;

         // Match each of the indexes that the user expects the property to have.
         for ( int j = 0; j < indexes->Length; j++ )
            // Determine whether the types specified by the user can be converted to index type.
            if ( CanConvertFrom( indexes[ j ], parameters[ j ]->ParameterType ) )
                        count += 1;
            else
                        break;

         // Determine whether the property has been found.
         if ( count == indexes->Length )
         {
            // Determine whether the return type can be converted to the properties type.
            if ( CanConvertFrom( returnType, match[ i ]->PropertyType ) )
                  return match[ i ];
            else
                  continue;
         }
      }
      return nullptr;
   }

private:

   // Determines whether type1 can be converted to type2. Check only for primitive types.
   bool CanConvertFrom( Type^ type1, Type^ type2 )
   {
      if ( type1->IsPrimitive && type2->IsPrimitive )
      {
         TypeCode typeCode1 = Type::GetTypeCode( type1 );
         TypeCode typeCode2 = Type::GetTypeCode( type2 );

         // If both type1 and type2 have the same type, return true.
         if ( typeCode1 == typeCode2 )
                  return true;

         // Possible conversions from Char follow.
         if ( typeCode1 == TypeCode::Char )
         {
            switch ( typeCode2 )
            {
               case TypeCode::UInt16:
                  return true;

               case TypeCode::UInt32:
                  return true;

               case TypeCode::Int32:
                  return true;

               case TypeCode::UInt64:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from Byte follow.
         if ( typeCode1 == TypeCode::Byte )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Char:
                  return true;

               case TypeCode::UInt16:
                  return true;

               case TypeCode::Int16:
                  return true;

               case TypeCode::UInt32:
                  return true;

               case TypeCode::Int32:
                  return true;

               case TypeCode::UInt64:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from SByte follow.
         if ( typeCode1 == TypeCode::SByte )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Int16:
                  return true;

               case TypeCode::Int32:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from UInt16 follow.
         if ( typeCode1 == TypeCode::UInt16 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::UInt32:
                  return true;

               case TypeCode::Int32:
                  return true;

               case TypeCode::UInt64:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from Int16 follow.
         if ( typeCode1 == TypeCode::Int16 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Int32:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from UInt32 follow.
         if ( typeCode1 == TypeCode::UInt32 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::UInt64:
                  return true;

               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from Int32 follow.
         if ( typeCode1 == TypeCode::Int32 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Int64:
                  return true;

               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from UInt64 follow.
         if ( typeCode1 == TypeCode::UInt64 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from Int64 follow.
         if ( typeCode1 == TypeCode::Int64 )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Single:
                  return true;

               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }

         // Possible conversions from Single follow.
         if ( typeCode1 == TypeCode::Single )
         {
            switch ( typeCode2 )
            {
               case TypeCode::Double:
                  return true;

               default:
                  return false;
            }
         }
      }

      return false;
   }

};

public ref class MyClass1
{
public:
   short myFieldB;
   int myFieldA;
   void MyMethod( long i, char k )
   {
      Console::WriteLine( "\nThis is MyMethod(long i, char k)" );
   }

   void MyMethod( long i, long j )
   {
      Console::WriteLine( "\nThis is MyMethod(long i, long j)" );
   }
};

int main()
{
   // Get the type of MyClass1.
   Type^ myType = MyClass1::typeid;

   // Get the instance of MyClass1.
   MyClass1^ myInstance = gcnew MyClass1;
   Console::WriteLine( "\nDisplaying the results of using the MyBinder binder.\n" );

   // Get the method information for MyMethod.
   array<Type^>^types = {short::typeid,short::typeid};
   MethodInfo^ myMethod = myType->GetMethod( "MyMethod", static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance), gcnew MyBinder, types, nullptr );
   Console::WriteLine( myMethod );

   // Invoke MyMethod.
   array<Object^>^obj = {32,32};
   myMethod->Invoke( myInstance, BindingFlags::InvokeMethod, gcnew MyBinder, obj, CultureInfo::CurrentCulture );
}
using System;
using System.Reflection;
using System.Globalization;

public class MyBinder : Binder 
{
    public MyBinder() : base()
    {
    }
    private class BinderState
    {
        public object[] args;
    }
    public override FieldInfo BindToField(
        BindingFlags bindingAttr,
        FieldInfo[] match,
        object value,
        CultureInfo culture
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        // Get a field for which the value parameter can be converted to the specified field type.
        for(int i = 0; i < match.Length; i++)
            if(ChangeType(value, match[i].FieldType, culture) != null)
                return match[i];
        return null;
    }
    public override MethodBase BindToMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        ref object[] args,
        ParameterModifier[] modifiers,
        CultureInfo culture,
        string[] names,
        out object state
        )
    {
        // Store the arguments to the method in a state object.
        BinderState myBinderState = new BinderState();
        object[] arguments = new Object[args.Length];
        args.CopyTo(arguments, 0);
        myBinderState.args = arguments;
        state = myBinderState;
        if(match == null)
            throw new ArgumentNullException();
        // Find a method that has the same parameters as those of the args parameter.
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of parameters that match.
            int count = 0;
            ParameterInfo[] parameters = match[i].GetParameters();
            // Go on to the next method if the number of parameters do not match.
            if(args.Length != parameters.Length)
                continue;
            // Match each of the parameters that the user expects the method to have.
            for(int j = 0; j < args.Length; j++)
            {
                // If the names parameter is not null, then reorder args.
                if(names != null)
                {
                    if(names.Length != args.Length)
                        throw new ArgumentException("names and args must have the same number of elements.");
                    for(int k = 0; k < names.Length; k++)
                        if(String.Compare(parameters[j].Name, names[k].ToString()) == 0)
                            args[j] = myBinderState.args[k];
                }
                // Determine whether the types specified by the user can be converted to the parameter type.
                if(ChangeType(args[j], parameters[j].ParameterType, culture) != null)
                    count += 1;
                else
                    break;
            }
            // Determine whether the method has been found.
            if(count == args.Length)
                return match[i];
        }
        return null;
    }
    public override object ChangeType(
        object value,
        Type myChangeType,
        CultureInfo culture
        )
    {
        // Determine whether the value parameter can be converted to a value of type myType.
        if(CanConvertFrom(value.GetType(), myChangeType))
            // Return the converted object.
            return Convert.ChangeType(value, myChangeType);
        else
            // Return null.
            return null;
    }
    public override void ReorderArgumentArray(
        ref object[] args,
        object state
        )
    {
        // Return the args that had been reordered by BindToMethod.
        ((BinderState)state).args.CopyTo(args, 0);
    }
    public override MethodBase SelectMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        Type[] types,
        ParameterModifier[] modifiers
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of parameters that match.
            int count = 0; 
            ParameterInfo[] parameters = match[i].GetParameters();
            // Go on to the next method if the number of parameters do not match.
            if(types.Length != parameters.Length)
                continue;
            // Match each of the parameters that the user expects the method to have.
            for(int j = 0; j < types.Length; j++)
                // Determine whether the types specified by the user can be converted to parameter type.
                if(CanConvertFrom(types[j], parameters[j].ParameterType))
                    count += 1;
                else
                    break;
            // Determine whether the method has been found.
            if(count == types.Length)
                return match[i];
        }
        return null;
    }
    public override PropertyInfo SelectProperty(
        BindingFlags bindingAttr,
        PropertyInfo[] match,
        Type returnType,
        Type[] indexes,
        ParameterModifier[] modifiers
        )
    {
        if(match == null)
            throw new ArgumentNullException("match");
        for(int i = 0; i < match.Length; i++)
        {
            // Count the number of indexes that match.
            int count = 0;
            ParameterInfo[] parameters = match[i].GetIndexParameters();
            // Go on to the next property if the number of indexes do not match.
            if(indexes.Length != parameters.Length)
                continue;
            // Match each of the indexes that the user expects the property to have.
            for(int j = 0; j < indexes.Length; j++)
                // Determine whether the types specified by the user can be converted to index type.
                if(CanConvertFrom(indexes[j], parameters[j].ParameterType))
                    count += 1;
                else
                    break;
            // Determine whether the property has been found.
            if(count == indexes.Length)
                // Determine whether the return type can be converted to the properties type.
                if(CanConvertFrom(returnType, match[i].PropertyType))
                    return match[i];
                else
                    continue;
        }
        return null;
    }
    // Determines whether type1 can be converted to type2. Check only for primitive types.
    private bool CanConvertFrom(Type type1, Type type2)
    {
        if(type1.IsPrimitive && type2.IsPrimitive)
        {
            TypeCode typeCode1 = Type.GetTypeCode(type1);
            TypeCode typeCode2 = Type.GetTypeCode(type2);
            // If both type1 and type2 have the same type, return true.
            if(typeCode1 == typeCode2)
                return true;
            // Possible conversions from Char follow.
            if(typeCode1 == TypeCode.Char)
                switch(typeCode2)
                {
                    case TypeCode.UInt16 : return true;
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Byte follow.
            if(typeCode1 == TypeCode.Byte)
                switch(typeCode2)
                {
                    case TypeCode.Char   : return true;
                    case TypeCode.UInt16 : return true;
                    case TypeCode.Int16  : return true;
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from SByte follow.
            if(typeCode1 == TypeCode.SByte)
                switch(typeCode2)
                {
                    case TypeCode.Int16  : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt16 follow.
            if(typeCode1 == TypeCode.UInt16)
                switch(typeCode2)
                {
                    case TypeCode.UInt32 : return true;
                    case TypeCode.Int32  : return true;
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int16 follow.
            if(typeCode1 == TypeCode.Int16)
                switch(typeCode2)
                {
                    case TypeCode.Int32  : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt32 follow.
            if(typeCode1 == TypeCode.UInt32)
                switch(typeCode2)
                {
                    case TypeCode.UInt64 : return true;
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int32 follow.
            if(typeCode1 == TypeCode.Int32)
                switch(typeCode2)
                {
                    case TypeCode.Int64  : return true;
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from UInt64 follow.
            if(typeCode1 == TypeCode.UInt64)
                switch(typeCode2)
                {
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Int64 follow.
            if(typeCode1 == TypeCode.Int64)
                switch(typeCode2)
                {
                    case TypeCode.Single : return true;
                    case TypeCode.Double : return true;
                    default              : return false;
                }
            // Possible conversions from Single follow.
            if(typeCode1 == TypeCode.Single)
                switch(typeCode2)
                {
                    case TypeCode.Double : return true;
                    default              : return false;
                }
        }
        return false;
    }
}
public class MyClass1
{
    public short myFieldB;
    public int myFieldA; 
    public void MyMethod(long i, char k)
    {
        Console.WriteLine("\nThis is MyMethod(long i, char k)");
    }
    public void MyMethod(long i, long j)
    {
        Console.WriteLine("\nThis is MyMethod(long i, long j)");
    }
}
public class Binder_Example
{
    public static void Main()
    {
        // Get the type of MyClass1.
        Type myType = typeof(MyClass1);
        // Get the instance of MyClass1.
        MyClass1 myInstance = new MyClass1();
        Console.WriteLine("\nDisplaying the results of using the MyBinder binder.\n");
        // Get the method information for MyMethod.
        MethodInfo myMethod = myType.GetMethod("MyMethod", BindingFlags.Public | BindingFlags.Instance,
            new MyBinder(), new Type[] {typeof(short), typeof(short)}, null);
        Console.WriteLine(myMethod);
        // Invoke MyMethod.
        myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, new MyBinder(), new Object[] {(int)32, (int)32}, CultureInfo.CurrentCulture);
    }
}
Imports System.Reflection
Imports System.Globalization

Public Class MyBinder
    Inherits Binder
    Public Sub New()
        MyBase.new()
    End Sub
    Private Class BinderState
        Public args() As Object
    End Class

    Public Overrides Function BindToField(ByVal bindingAttr As BindingFlags, ByVal match() As FieldInfo, ByVal value As Object, ByVal culture As CultureInfo) As FieldInfo
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        ' Get a field for which the value parameter can be converted to the specified field type.
        Dim i As Integer
        For i = 0 To match.Length - 1
            If Not (ChangeType(value, match(i).FieldType, culture) Is Nothing) Then
                Return match(i)
            End If
        Next i
        Return Nothing
    End Function 'BindToField

    Public Overrides Function BindToMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByRef args() As Object, ByVal modifiers() As ParameterModifier, ByVal culture As CultureInfo, ByVal names() As String, ByRef state As Object) As MethodBase
        ' Store the arguments to the method in a state object.
        Dim myBinderState As New BinderState()
        Dim arguments() As Object = New [Object](args.Length) {}
        args.CopyTo(arguments, 0)
        myBinderState.args = arguments
        state = myBinderState

        If match Is Nothing Then
            Throw New ArgumentNullException()
        End If
        ' Find a method that has the same parameters as those of args.
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of parameters that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetParameters()
            ' Go on to the next method if the number of parameters do not match.
            If args.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the parameters that the user expects the method to have.
            Dim j As Integer
            For j = 0 To args.Length - 1
                ' If names is not null, then reorder args.
                If Not (names Is Nothing) Then
                    If names.Length <> args.Length Then
                        Throw New ArgumentException("names and args must have the same number of elements.")
                    End If
                    Dim k As Integer
                    For k = 0 To names.Length - 1
                        If String.Compare(parameters(j).Name, names(k).ToString()) = 0 Then
                            args(j) = myBinderState.args(k)
                        End If
                    Next k
                End If ' Determine whether the types specified by the user can be converted to parameter type.
                If Not (ChangeType(args(j), parameters(j).ParameterType, culture) Is Nothing) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j
            ' Determine whether the method has been found.
            If count = args.Length Then
                Return match(i)
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'BindToMethod

    Public Overrides Function ChangeType(ByVal value As Object, ByVal myChangeType As Type, ByVal culture As CultureInfo) As Object
        ' Determine whether the value parameter can be converted to a value of type myType.
        If CanConvertFrom(value.GetType(), myChangeType) Then
            ' Return the converted object.
            Return Convert.ChangeType(value, myChangeType)
            ' Return null.
        Else
            Return Nothing
        End If
    End Function 'ChangeType

    Public Overrides Sub ReorderArgumentArray(ByRef args() As Object, ByVal state As Object)
        'Redimension the array to hold the state values.
        ReDim args(CType(state, BinderState).args.Length)
        ' Return the args that had been reordered by BindToMethod.
        CType(state, BinderState).args.CopyTo(args, 0)
    End Sub

    Public Overrides Function SelectMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByVal types() As Type, ByVal modifiers() As ParameterModifier) As MethodBase
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of parameters that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetParameters()
            ' Go on to the next method if the number of parameters do not match.
            If types.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the parameters that the user expects the method to have.
            Dim j As Integer
            For j = 0 To types.Length - 1
                ' Determine whether the types specified by the user can be converted to parameter type.
                If CanConvertFrom(types(j), parameters(j).ParameterType) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j ' Determine whether the method has been found.
            If count = types.Length Then
                Return match(i)
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'SelectMethod
    Public Overrides Function SelectProperty(ByVal bindingAttr As BindingFlags, ByVal match() As PropertyInfo, ByVal returnType As Type, ByVal indexes() As Type, ByVal modifiers() As ParameterModifier) As PropertyInfo
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of indexes that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetIndexParameters()

            ' Go on to the next property if the number of indexes do not match.
            If indexes.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the indexes that the user expects the property to have.
            Dim j As Integer
            For j = 0 To indexes.Length - 1
                ' Determine whether the types specified by the user can be converted to index type.
                If CanConvertFrom(indexes(j), parameters(j).ParameterType) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j ' Determine whether the property has been found.
            If count = indexes.Length Then
                ' Determine whether the return type can be converted to the properties type.
                If CanConvertFrom(returnType, match(i).PropertyType) Then
                    Return match(i)
                Else
                    GoTo ContinueFori
                End If
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'SelectProperty

    ' Determine whether type1 can be converted to type2. Check only for primitive types.
    Private Function CanConvertFrom(ByVal type1 As Type, ByVal type2 As Type) As Boolean
        If type1.IsPrimitive And type2.IsPrimitive Then
            Dim typeCode1 As TypeCode = Type.GetTypeCode(type1)
            Dim typeCode2 As TypeCode = Type.GetTypeCode(type2)
            ' If both type1 and type2 have same type, return true.
            If typeCode1 = typeCode2 Then
                Return True
            End If ' Possible conversions from Char follow.
            If typeCode1 = TypeCode.Char Then
                Select Case typeCode2
                    Case TypeCode.UInt16
                        Return True
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Byte follow.
            If typeCode1 = TypeCode.Byte Then
                Select Case typeCode2
                    Case TypeCode.Char
                        Return True
                    Case TypeCode.UInt16
                        Return True
                    Case TypeCode.Int16
                        Return True
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from SByte follow.
            If typeCode1 = TypeCode.SByte Then
                Select Case typeCode2
                    Case TypeCode.Int16
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt16 follow.
            If typeCode1 = TypeCode.UInt16 Then
                Select Case typeCode2
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int16 follow.
            If typeCode1 = TypeCode.Int16 Then
                Select Case typeCode2
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt32 follow.
            If typeCode1 = TypeCode.UInt32 Then
                Select Case typeCode2
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int32 follow.
            If typeCode1 = TypeCode.Int32 Then
                Select Case typeCode2
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt64 follow.
            If typeCode1 = TypeCode.UInt64 Then
                Select Case typeCode2
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int64 follow.
            If typeCode1 = TypeCode.Int64 Then
                Select Case typeCode2
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Single follow.
            If typeCode1 = TypeCode.Single Then
                Select Case typeCode2
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If
        End If
        Return False
    End Function 'CanConvertFrom
End Class


Public Class MyClass1
    Public myFieldB As Short
    Public myFieldA As Integer

    Public Overloads Sub MyMethod(ByVal i As Long, ByVal k As Char)
        Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, char k).")
    End Sub

    Public Overloads Sub MyMethod(ByVal i As Long, ByVal j As Long)
        Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, long j).")
    End Sub
End Class


Public Class Binder_Example
    Public Shared Sub Main()
        ' Get the type of MyClass1.
        Dim myType As Type = GetType(MyClass1)
        ' Get the instance of MyClass1.
        Dim myInstance As New MyClass1()
        Console.WriteLine(ControlChars.Cr & "Displaying the results of using the MyBinder binder.")
        Console.WriteLine()
        ' Get the method information for MyMethod.
        Dim myMethod As MethodInfo = myType.GetMethod("MyMethod", BindingFlags.Public Or BindingFlags.Instance, New MyBinder(), New Type() {GetType(Short), GetType(Short)}, Nothing)
        Console.WriteLine(MyMethod)
        ' Invoke MyMethod.
        myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, New MyBinder(), New [Object]() {CInt(32), CInt(32)}, CultureInfo.CurrentCulture)
    End Sub
End Class

설명

이 인스턴스에 의해 리플렉션된 메서드를 호출 하는 동적으로 obj, 지정된 된 매개 변수를 전달 합니다.Dynamically invokes the method reflected by this instance on obj, and passes along the specified parameters. 메서드가 정적 이면는 obj 매개 변수가 무시 됩니다.If the method is static, the obj parameter is ignored. 비정적 메서드에 대해 obj 상속 하거나 메서드를 선언 하 고,이 클래스와 동일한 형식 이어야 하는 클래스의 인스턴스여야 합니다.For non-static methods, obj should be an instance of a class that inherits or declares the method and must be the same type as this class. 메서드 매개 변수가 없는의 값이 있으면 parameters 있어야 null합니다.If the method has no parameters, the value of parameters should be null. 그렇지 않은 경우 개수, 형식 및에서 요소의 순서 parameters 수, 형식 및이 인스턴스에서 리플 렉 트 메서드에 대 한 매개 변수의 순서와 동일 해야 합니다.Otherwise, the number, type, and order of elements in parameters should be identical to the number, type, and order of parameters for the method reflected by this instance.

에 대 한 호출의 선택적 매개 변수를 생략할 수 없습니다 Invoke합니다.You may not omit optional parameters in calls to Invoke. 선택적 매개 변수를 생략 하는 메서드를 호출 하려면 호출 해야 Type.InvokeMember 대신 합니다.To invoke a method omitting optional parameters, you should call Type.InvokeMember instead.

참고

이 메서드 오버 로드 인스턴스 생성자 호출을 사용 하는 경우에 대 한 제공 된 개체가 obj 다시 초기화 됩니다; 즉, 모든 인스턴스 이니셜라이저 실행 됩니다.If this method overload is used to invoke an instance constructor, the object supplied for obj is reinitialized; that is, all instance initializers are executed. 반환 값은 null입니다.The return value is null. 클래스 생성자를 호출 하는 경우 클래스를 다시 초기화 됩니다. 즉, 모든 클래스 이니셜라이저가 실행 됩니다.If a class constructor is invoked, the class is reinitialized; that is, all class initializers are executed. 반환 값은 null입니다.The return value is null.

기본 값으로 전달 매개 변수에 대 한 일반 확대 이루어집니다 (Int16-> Int32, 예를 들어).For pass-by-value primitive parameters, normal widening is performed (Int16 -> Int32, for example). 값으로 전달 참조 매개 변수에 대 한 일반적인 참조 확대 (기본 클래스 및 인터페이스 형식에 기본 클래스를 파생된 클래스) 허용 됩니다.For pass-by-value reference parameters, normal reference widening is allowed (derived class to base class, and base class to interface type). 그러나 참조로 전달 기본 매개 변수 형식이 정확히 일치 해야 합니다.However, for pass-by-reference primitive parameters, the types must match exactly. 참조로 전달 참조 매개 변수에 대 한 일반 확대 계속 적용 됩니다.For pass-by-reference reference parameters, the normal widening still applies.

예를 들어 메서드를 반영 하 여이 인스턴스는 변수로 선언 public boolean Compare(String a, String b), 한 다음 parameters 의 배열 이어야 Objects 길이가 2 인 되도록 parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").For example, if the method reflected by this instance is declared as public boolean Compare(String a, String b), then parameters should be an array of Objects with length 2 such that parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").

현재 메서드의 매개 변수 값 형식 및 해당 인수 이면 parametersnull, 런타임에 값 형식의 0으로 초기화 된 인스턴스를 전달 합니다.If a parameter of the current method is a value type, and the corresponding argument in parameters is null, the runtime passes a zero-initialized instance of the value type.

리플렉션 가상 메서드를 호출 하는 경우 동적 메서드 조회를 사용 합니다.Reflection uses dynamic method lookup when invoking virtual methods. 예를 들어, 클래스 B는 클래스에서 상속 하 고 모두 M 이라는 가상 메서드를 구현 합니다. 이제 있다고 가정 하 고는 MethodInfo A. 클래스에 M을 나타내는 개체 사용 하는 경우는 Invoke 리플렉션 클래스 2. 제공한 구현을 사용 합니다. 그런 다음 M b 형식의 개체에서 호출할 메서드 형식 B의 개체를 A로 캐스팅 하는 경우에 클래스 B에 의해 지정 된 구현이 사용 됩니다 (아래 코드 샘플 참조).For example, suppose that class B inherits from class A and both implement a virtual method named M. Now suppose that you have a MethodInfo object that represents M on class A. If you use the Invoke method to invoke M on an object of type B, then reflection will use the implementation given by class B. Even if the object of type B is cast to A, the implementation given by class B is used (see code sample below).

반면에 메서드가 가상이 아닌 경우 다음 리플렉션은 구현을 사용 형식이 올 지정한는 MethodInfo 대상으로 전달 되는 개체의 유형에 관계 없이 가져온 합니다.On the other hand, if the method is non-virtual, then reflection will use the implementation given by the type from which the MethodInfo was obtained, regardless of the type of the object passed as the target.

완전히 신뢰할 수 있는 코드에 대 한 액세스 제한이 없습니다.Access restrictions are ignored for fully trusted code. 즉, 개인 생성자, 메서드, 필드 및 속성 액세스 하 고 수 코드를 완전히 신뢰할 수 있는 경우 리플렉션을 통해 호출 합니다.That is, private constructors, methods, fields, and properties can be accessed and invoked via reflection whenever the code is fully trusted.

호출 된 메서드가 예외를 throw 하는 경우 TargetInvocationException.GetException 예외를 반환 합니다.If the invoked method throws an exception, TargetInvocationException.GetException returns the exception. 이 구현에서 throw 된 NotSupportedException합니다.This implementation throws a NotSupportedException.

참고

부터 합니다 .NET Framework 2.0 서비스 팩 1.NET Framework 2.0 Service Pack 1,이 메서드를 사용 하 여 호출자에 게 부여 된 경우 public이 아닌 멤버에 액세스할 수 있습니다 ReflectionPermission 사용 하 여는 ReflectionPermissionFlag.RestrictedMemberAccess 플래그 및 public이 아닌 멤버의 권한 부여 집합 호출자 에게만 부여 된 집합 또는 하위 집합 그 합니다.Starting with the .NET Framework 2.0 서비스 팩 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public members if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public members is restricted to the caller's grant set, or a subset thereof. (참조 리플렉션의 보안 고려 사항.)(See Security Considerations for Reflection.)

이 기능을 사용하려면 애플리케이션이 .NET Framework 3.5.NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

보안

ReflectionPermission
호출 될 때 런타임에 바인딩된 메커니즘을 통해 같은 InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])합니다.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). 연관된 열거형: MemberAccessAssociated enumeration: MemberAccess.

추가 정보

적용 대상