Delegate.CreateDelegate 메서드

정의

지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type.

오버로드

CreateDelegate(Type, Type, String, Boolean, Boolean)

지정한 대/소문자 구분과 바인딩 실패 시 지정한 동작을 기반으로 지정한 클래스의 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, Type, String, Boolean)

지정한 대/소문자 구분 여부를 기반으로 지정한 클래스의 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

CreateDelegate(Type, Object, String, Boolean)

지정된 대/소문자 구분 여부를 기반으로 지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

CreateDelegate(Type, Object, MethodInfo, Boolean)

지정한 첫 번째 인수와 바인딩 실패 시 지정한 동작을 기반으로 지정한 정적 또는 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

CreateDelegate(Type, Object, String, Boolean, Boolean)

지정한 대/소문자 구분과 바인딩 실패 시 지정한 동작을 기반으로 지정한 클래스 인스턴스에서 호출하는 지정한 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, MethodInfo, Boolean)

바인딩 실패 시 지정한 동작을 기반으로 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

CreateDelegate(Type, Object, String)

지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, MethodInfo)

지정한 첫 번째 인수를 사용하여 지정한 정적 또는 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Type, String)

지정된 클래스의 지정된 정적 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, MethodInfo)

지정된 정적 메서드를 나타내기 위해서 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, Type, String, Boolean, Boolean)

지정한 대/소문자 구분과 바인딩 실패 시 지정한 동작을 기반으로 지정한 클래스의 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate? CreateDelegate (Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * Type * string * bool * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Type, method As String, ignoreCase As Boolean, throwOnBindFailure As Boolean) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Type

method를 구현하는 클래스를 나타내는 Type입니다.The Type representing the class that implements method.

method
String

대리자가 나타내는 정적 메서드의 이름입니다.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

메서드의 이름을 비교할 때 대/소문자 구분을 무시할지를 나타내는 부울입니다.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

method를 바인딩할 수 없습니다. 예외가 발생하면 true이고, 예외가 발생하지 않으면 false입니다.true to throw an exception if method cannot be bound; otherwise, false.

반환

Delegate

지정된 클래스의 지정된 정적 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified static method of the specified class.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- target이(가) RuntimeType가 아닌 경우target is not a RuntimeType.

또는-or- target이 개방형 제네릭 형식인 경우.target is an open generic type. 즉, 해당 ContainsGenericParameters 속성이 true인 경우That is, its ContainsGenericParameters property is true.

또는-or- methodstatic 메서드(Visual Basic의 경우 Shared 메서드)가 아닌 경우method is not a static method (Shared method in Visual Basic).

또는-or- 예를 들어 찾을 수 없고 throwOnBindFailuretrue이기 때문에 method를 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 정적 메서드에만 대리자를 만듭니다.This method creates delegates for static methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, Type, String, Boolean)

지정한 대/소문자 구분 여부를 기반으로 지정한 클래스의 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method, bool ignoreCase);
public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase);
static member CreateDelegate : Type * Type * string * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Type, method As String, ignoreCase As Boolean) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Type

method를 구현하는 클래스를 나타내는 Type입니다.The Type representing the class that implements method.

method
String

대리자가 나타내는 정적 메서드의 이름입니다.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

메서드의 이름을 비교할 때 대/소문자 구분을 무시할지를 나타내는 부울입니다.A Boolean indicating whether to ignore the case when comparing the name of the method.

반환

Delegate

지정된 클래스의 지정된 정적 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified static method of the specified class.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- target이(가) RuntimeType가 아닌 경우target is not a RuntimeType.

또는-or- target이 개방형 제네릭 형식인 경우.target is an open generic type. 즉, 해당 ContainsGenericParameters 속성이 true인 경우That is, its ContainsGenericParameters property is true.

또는-or- methodstatic 메서드(Visual Basic의 경우 Shared 메서드)가 아닌 경우method is not a static method (Shared method in Visual Basic).

또는-or- 예를 들어 method는 찾을 수 없기 때문에 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 정적 메서드에만 대리자를 만듭니다.This method creates delegates for static methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

이 메서드 오버 로드는 CreateDelegate(Type, Type, String, Boolean, Boolean) 에 대해를 지정 하 여 메서드 오버 로드를 호출 하는 것과 같습니다 true throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, Object, String, Boolean)

지정된 대/소문자 구분 여부를 기반으로 지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method, bool ignoreCase);
public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase);
static member CreateDelegate : Type * obj * string * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Object, method As String, ignoreCase As Boolean) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Object

method가 호출되는 클래스 인스턴스입니다.The class instance on which method is invoked.

method
String

대리자가 나타내는 인스턴스 메서드의 이름입니다.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

메서드의 이름을 비교할 때 대/소문자 구분을 무시할지를 나타내는 부울입니다.A Boolean indicating whether to ignore the case when comparing the name of the method.

반환

Delegate

지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method는 인스턴스 메서드가 아닙니다.method is not an instance method.

또는-or- 예를 들어 method는 찾을 수 없기 때문에 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 인스턴스 메서드에만 대리자를 만듭니다.This method creates delegates for instance methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

이 메서드 오버 로드는 CreateDelegate(Type, Object, String, Boolean, Boolean) 에 대해를 지정 하 여 메서드 오버 로드를 호출 하는 것과 같습니다 true throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, Object, MethodInfo, Boolean)

지정한 첫 번째 인수와 바인딩 실패 시 지정한 동작을 기반으로 지정한 정적 또는 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ firstArgument, System::Reflection::MethodInfo ^ method, bool throwOnBindFailure);
public static Delegate? CreateDelegate (Type type, object? firstArgument, System.Reflection.MethodInfo method, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, firstArgument As Object, method As MethodInfo, throwOnBindFailure As Boolean) As Delegate

매개 변수

type
Type

만들 디자이너 형식을 나타내는 Type입니다.A Type representing the type of delegate to create.

firstArgument
Object

대리자가 나타내는 메서드의 첫 번째 인수인 Object입니다.An Object that is the first argument of the method the delegate represents. 인스턴스 메서드의 경우 인스턴스 형식과 호환되어야 합니다.For instance methods, it must be compatible with the instance type.

method
MethodInfo

대리자가 나타내는 정적 또는 인스턴스 메서드를 설명하는 MethodInfo입니다.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

method를 바인딩할 수 없습니다. 예외가 발생하면 true이고, 예외가 발생하지 않으면 false입니다.true to throw an exception if method cannot be bound; otherwise, false.

반환

Delegate

지정한 정적 또는 인스턴스 메서드를 나타내는 지정한 형식의 대리자이거나, throwOnBindFailurefalse이고 대리자를 method에 바인딩할 수 없으면 null입니다.A delegate of the specified type that represents the specified static or instance method, or null if throwOnBindFailure is false and the delegate cannot be bound to method.

예외

type이(가) null인 경우type is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method를 바인딩할 수 없으므로 throwOnBindFailuretrue입니다.method cannot be bound, and throwOnBindFailure is true.

또는-or- method이(가) RuntimeMethodInfo가 아닌 경우method is not a RuntimeMethodInfo. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

예제

이 섹션에는 세 가지 코드 예제가 있습니다.This section contains three code examples. 첫 번째 예제에서는 생성 될 수 있는 네 가지 종류의 대리자 (인스턴스 메서드를 통해 닫힘, 인스턴스 메서드를 통해 열기, 정적 메서드를 통해 열기 및 정적 메서드를 통해 닫힘)를 보여 줍니다.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

두 번째 코드 예제에서는 호환 되는 매개 변수 형식 및 반환 형식을 보여 줍니다.The second code example demonstrates compatible parameter types and return types.

세 번째 코드 예제에서는 단일 대리자 형식을 정의 하 고 대리자 형식이 나타낼 수 있는 모든 메서드를 보여 줍니다.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

예제 1Example 1

다음 코드 예제에서는 메서드의이 오버 로드를 사용 하 여 대리자를 만들 수 있는 네 가지 방법을 보여 줍니다 CreateDelegate .The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

참고

및를 지정 하는 메서드의 오버 로드에는 두 가지가 있습니다 CreateDelegate firstArgument MethodInfo . 즉, 바인딩 실패 시 throw 여부를 지정 하는 것을 허용 하 고 다른 하나는 항상 throw 한다는 점을 제외 하 고는 동일 합니다.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

예제에서는 C 정적 메서드 및 인스턴스 메서드를 사용 하 여 클래스를 선언 M2 M1 하 고, 세 개의 대리자 형식으로 인스턴스를 사용 하 고 문자열을 사용 D1 C D2 하며 문자열을 사용 하 고 인수를 사용 D3 하지 않습니다.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

이라는 두 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A second class named Example contains the code that creates the delegates.

  • 인스턴스에 대해 닫혀 있는 형식의 대리자 D2 C 가 인스턴스 메서드에 대해 만들어집니다 M1 .A delegate of type D2, closed over an instance of C, is created for the instance method M1. 의 바인딩된 인스턴스가 항상 사용 됨을 보여 주기 위해 다른 문자열로 호출 됩니다 C .It is invoked with different strings, to show that the bound instance of C is always used.

  • D1인스턴스 메서드에 대해 개방형 인스턴스 메서드를 나타내는 형식의 대리자가 만들어집니다 M1 .A delegate of type D1, representing an open instance method, is created for the instance method M1. 대리자가 호출 될 때 인스턴스를 전달 해야 합니다.An instance must be passed when the delegate is invoked.

  • D2정적 메서드에 대해 개방형 정적 메서드를 나타내는 형식의 대리자가 만들어집니다 M2 .A delegate of type D2, representing an open static method, is created for the static method M2.

  • 마지막으로 D3 , 문자열에 대해 폐쇄형 형식의 대리자가 정적 메서드에 대해 만들어집니다 M2 .Finally, a delegate of type D3, closed over a string, is created for the static method M2. 바인딩된 문자열을 사용 함을 표시 하기 위해 메서드가 호출 됩니다.The method is invoked to show that it uses the bound string.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s)
    {
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }

    public static void M2(string s)
    {
        Console.WriteLine("Static method M2 on C:  s = {0}", s);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1",
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;

        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test =
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for
        // example, if mi1 happened to represent a method of
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }

        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");

        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method.
        //
        d2("Hello, World!");
        d2("Hi, Mom!");

        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and
        // the delegate is bound to this string. Use delegate type
        // D3 with static method M2.
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3),
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
'

예제 2Example 2

다음 코드 예제에서는 매개 변수 형식 및 반환 형식의 호환성을 보여 줍니다.The following code example demonstrates compatibility of parameter types and return types.

참고

이 코드 예제에서는 CreateDelegate(Type, MethodInfo) 메서드 오버 로드를 사용 합니다.This code example uses the CreateDelegate(Type, MethodInfo) method overload. 에서 사용 하는 다른 오버 로드를 사용 하는 것 MethodInfo 도 유사 합니다.The use of other overloads that take MethodInfo is similar.

코드 예제에서는 라는 기본 클래스 BaseDerived 에서 파생 되는 이라는 클래스를 정의 합니다 Base .The code example defines a base class named Base and a class named Derived that derives from Base. 파생 클래스에는 static Shared MyMethod 형식의 매개 변수 하 나와 Base 의 반환 형식으로 명명 된 (Visual Basic) 메서드가 있습니다 Derived .The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. 또한 코드 예제에서는 Example 형식의 매개 변수 하 나와의 반환 형식을 포함 하는 라는 대리자를 정의 합니다 Derived Base .The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

이 코드 예제에서는 라는 대리자를 사용 하 여 메서드를 나타낼 수 있음을 보여 줍니다 Example MyMethod .The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. 메서드를 대리자에 바인딩할 수 있는 이유는 다음과 같습니다.The method can be bound to the delegate because:

  • 대리자의 매개 변수 형식 ( Derived )은 MyMethod Base 대리자의 인수를에 전달 하는 것이 항상 안전 하도록 ()의 매개 변수 형식 보다 더 제한적입니다 MyMethod .The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • 메서드의 반환 형식을 MyMethod Derived Base 대리자의 반환 형식으로 캐스팅 하는 것은 항상 안전 하기 때문에 ()의 반환 형식은 대리자의 매개 변수 형식 () 보다 더 제한적입니다.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

코드 예제에서는 출력을 생성 하지 않습니다.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base).
        //
        Example ex =
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //
        Base b = ex(new Derived());
    }
}
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

예 3Example 3

다음 코드 예제에서는 단일 대리자 형식이 나타낼 수 있는 모든 메서드를 보여 줍니다.The following code example shows all the methods a single delegate type can represent.

참고

및를 지정 하는 메서드의 오버 로드에는 두 가지가 있습니다 CreateDelegate firstArgument MethodInfo . 즉, 바인딩 실패 시 throw 여부를 지정 하는 것을 허용 하 고 다른 하나는 항상 throw 한다는 점을 제외 하 고는 동일 합니다.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

이 코드 예제에서는 두 클래스 CF 를 정의 하 고 D 형식의 인수 하나를 사용 하는 대리자 형식을 정의 합니다 C .The code example defines two classes, C and F, and a delegate type D with one argument of type C. 클래스에 일치 하는 정적 및 인스턴스 메서드, 및이 있고 M1 M3 클래스에 M4 C 도 인수가 없는 인스턴스 메서드가 있습니다 M2 .The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

이라는 세 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A third class named Example contains the code that creates the delegates.

  • 대리자는 형식 및 형식의 인스턴스 메서드에 대해 만들어지며 M1 C F , 각각은 해당 형식의 인스턴스를 통해 닫힙니다.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. M1형식의 메서드는 C ID 바인딩된 인스턴스와 인수의 속성을 표시 합니다.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • 형식의 메서드에 대 한 대리자가 만들어집니다 M2 C .A delegate is created for method M2 of type C. 이 대리자의 인수는 인스턴스 메서드의 숨겨진 첫 번째 인수를 나타내는 개방형 인스턴스 대리자입니다.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. 메서드에 다른 인수가 없습니다.The method has no other arguments.

  • 대리자는 형식 및 형식의 정적 메서드에 대해 만들어지므로 M3 C F 개방형 정적 대리자입니다.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • 마지막으로, 형식 및 형식의 정적 메서드에 대 한 대리자가 만들어집니다 M4 C F . 각 메서드는 선언 형식을 첫 번째 인수로 가지 며 형식의 인스턴스가 제공 되므로 첫 번째 인수에 대해 대리자가 닫힙니다.Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. M4형식의 메서드는 C ID 바인딩된 인스턴스와 인수의 속성을 표시 합니다.Method M4 of type C displays the ID properties of the bound instance and of the argument.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
//
public delegate void D(C c);

// Declare two sample classes, C and F. Class C has an ID
// property so instances can be identified.
//
public class C
{
    private int id;
    public int ID { get { return id; }}
    public C(int id) { this.id = id; }

    public void M1(C c)
    {
        Console.WriteLine("Instance method M1(C c) on C:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }

    public void M2()
    {
        Console.WriteLine("Instance method M2() on C:  this.id = {0}",
            this.id);
    }

    public static void M3(C c)
    {
        Console.WriteLine("Static method M3(C c) on C:  c.ID = {0}", c.ID);
    }

    public static void M4(C c1, C c2)
    {
        Console.WriteLine("Static method M4(C c1, C c2) on C:  c1.ID = {0}, c2.ID = {1}",
            c1.ID, c2.ID);
    }
}

public class F
{
    public void M1(C c)
    {
        Console.WriteLine("Instance method M1(C c) on F:  c.ID = {0}",
            c.ID);
    }

    public static void M3(C c)
    {
        Console.WriteLine("Static method M3(C c) on F:  c.ID = {0}", c.ID);
    }

    public static void M4(F f, C c)
    {
        Console.WriteLine("Static method M4(F f, C c) on F:  c.ID = {0}",
            c.ID);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);
        C c2 = new C(1491);
        F f1 = new F();

        D d;

        // Instance method with one argument of type C.
        MethodInfo cmi1 = typeof(C).GetMethod("M1");
        // Instance method with no arguments.
        MethodInfo cmi2 = typeof(C).GetMethod("M2");
        // Static method with one argument of type C.
        MethodInfo cmi3 = typeof(C).GetMethod("M3");
        // Static method with two arguments of type C.
        MethodInfo cmi4 = typeof(C).GetMethod("M4");

        // Instance method with one argument of type C.
        MethodInfo fmi1 = typeof(F).GetMethod("M1");
        // Static method with one argument of type C.
        MethodInfo fmi3 = typeof(F).GetMethod("M3");
        // Static method with an argument of type F and an argument
        // of type C.
        MethodInfo fmi4 = typeof(F).GetMethod("M4");

        Console.WriteLine("\nAn instance method on any type, with an argument of type C.");
        // D can represent any instance method that exactly matches its
        // signature. Methods on C and F are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi1);
        d(c2);
        d = (D) Delegate.CreateDelegate(typeof(D), f1, fmi1);
        d(c2);

        Console.WriteLine("\nAn instance method on C with no arguments.");
        // D can represent an instance method on C that has no arguments;
        // in this case, the argument of D represents the hidden first
        // argument of any instance method. The delegate acts like a
        // static method, and an instance of C must be passed each time
        // it is invoked.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi2);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of type C.");
        // D can represent any static method with the same signature.
        // Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi3);
        d(c1);
        d = (D) Delegate.CreateDelegate(typeof(D), null, fmi3);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of");
        Console.WriteLine("    that type and an argument of type C.");
        // D can represent any static method with one argument of the
        // type the method belongs and a second argument of type C.
        // In this case, the method is closed over the instance of
        // supplied for the its first argument, and acts like an instance
        // method. Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi4);
        d(c2);
        Delegate test =
            Delegate.CreateDelegate(typeof(D), f1, fmi4, false);

        // This final example specifies false for throwOnBindFailure
        // in the call to CreateDelegate, so the variable 'test'
        // contains Nothing if the method fails to bind (for
        // example, if fmi4 happened to represent a method of
        // some class other than F).
        //
        if (test != null)
        {
            d = (D) test;
            d(c2);
        }
    }
}

/* This code example produces the following output:

An instance method on any type, with an argument of type C.
Instance method M1(C c) on C:  this.id = 42, c.ID = 1491
Instance method M1(C c) on F:  c.ID = 1491

An instance method on C with no arguments.
Instance method M2() on C:  this.id = 42

A static method on any type, with an argument of type C.
Static method M3(C c) on C:  c.ID = 42
Static method M3(C c) on F:  c.ID = 42

A static method on any type, with an argument of
    that type and an argument of type C.
Static method M4(C c1, C c2) on C:  c1.ID = 42, c2.ID = 1491
Static method M4(F f, C c) on F:  c.ID = 1491
*/
Imports System.Reflection
Imports System.Security.Permissions

' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C) 

' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C

    Private _id As Integer

    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property

    Public Sub New(ByVal newId As Integer) 
        Me._id = newId
    End Sub
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
            Me.id, c.ID)
    End Sub
    
    Public Sub M2() 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
        Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
            c1.ID, c2.ID)
    End Sub
End Class


Public Class F
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal f As F, ByVal c As C) 
        Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        Dim c2 As New C(1491)
        Dim f1 As New F()
        
        Dim d As D
        
        ' Instance method with one argument of type C.
        Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
        ' Instance method with no arguments.
        Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
        ' Shared method with one argument of type C.
        Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
        ' Shared method with two arguments of type C.
        Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
        
        ' Instance method with one argument of type C.
        Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
        ' Shared method with one argument of type C.
        Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
        ' Shared method with an argument of type F and an 
        ' argument of type C.
        Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
        
        Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
        ' D can represent any instance method that exactly matches its
        ' signature. Methods on C and F are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
        d(c2)
        d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
        d(c2)
        
        Console.WriteLine(vbLf & "An instance method on C with no arguments.")
        ' D can represent an instance method on C that has no arguments;
        ' in this case, the argument of D represents the hidden first
        ' argument of any instance method. The delegate acts like a 
        ' Shared method, and an instance of C must be passed each time
        ' it is invoked.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
        ' D can represent any Shared method with the same signature.
        ' Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
        d(c1)
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
        Console.WriteLine("    that type and an argument of type C.")
        ' D can represent any Shared method with one argument of the
        ' type the method belongs and a second argument of type C.
        ' In this case, the method is closed over the instance of
        ' supplied for the its first argument, and acts like an instance
        ' method. Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
        d(c2)
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D), f1, fmi4, false)

        ' This final example specifies False for throwOnBindFailure 
        ' in the call to CreateDelegate, so the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if fmi4 happened to represent a method of  
        ' some class other than F).
        '
        If test IsNot Nothing Then
            d = CType(test, D)
            d(c2)
        End If
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C:  this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F:  c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C:  this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C:  c.ID = 42
'Shared method M3(c As C) on F:  c.ID = 42
'
'A Shared method on any type, with an argument of
'    that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C:  c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F:  c.ID = 1491
'

설명

CreateDelegate(Type, Object, MethodInfo)바인딩 실패 시 항상 throw 되는이 메서드 오버 로드 및 메서드 오버 로드는 대리자를 만드는 가장 유연한 방법을 제공 합니다.This method overload and the CreateDelegate(Type, Object, MethodInfo) method overload, which always throws on failure to bind, provide the most flexible way to create delegates. 이를 사용 하 여 첫 번째 인수를 사용 하거나 사용 하지 않고 정적 또는 인스턴스 메서드에 대 한 대리자를 만들 수 있습니다.You can use them to create delegates for either static or instance methods, with or without a first argument.

참고

첫 번째 인수를 제공 하지 않으면 CreateDelegate(Type, MethodInfo, Boolean) 성능 향상을 위해 메서드 오버 로드를 사용 합니다.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo, Boolean) method overload for better performance.

대리자 형식과 메서드에 호환 되는 반환 형식이 있어야 합니다.The delegate type and the method must have compatible return types. 즉,의 반환 형식을 method 의 반환 형식에 할당할 수 있어야 합니다 type .That is, the return type of method must be assignable to the return type of type.

가 제공 되는 경우 대리자가 호출 될 때마다 firstArgument 로 전달 되 고, method firstArgument 는 대리자에 바인딩되고, 대리자는 첫 번째 인수에 대해 닫혀 있다고 합니다.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. methodstatic (Visual Basic) 인 경우 Shared 대리자를 호출할 때 제공 되는 인수 목록에는 첫 번째를 제외한 모든 매개 변수가 포함 됩니다. method 가 인스턴스 메서드인 경우 firstArgument 는 숨겨진 인스턴스 매개 변수로 전달 됩니다 ( this c #의 경우 또는 Me Visual Basic에서로 나타냄).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

를 제공 하는 경우 firstArgument 의 첫 번째 매개 변수는 method 참조 형식 이어야 하 고 firstArgument 해당 형식과 호환 되어야 합니다.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

중요

methodstatic ( Shared Visual Basic)이 고 첫 번째 매개 변수가 또는 형식이 면는 Object ValueType firstArgument 값 형식일 수 있습니다.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. 이 경우 firstArgument 자동으로 boxing 됩니다.In this case firstArgument is automatically boxed. C # 또는 Visual Basic 함수 호출 에서처럼 다른 인수에 대해서는 자동 boxing이 발생 하지 않습니다.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

firstArgument가 null 참조이 고 method 가 인스턴스 메서드인 경우 결과는 대리자 형식 및의 시그니처에 따라 달라 집니다 type method .If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • 의 시그니처에서 type 의 숨겨진 첫 번째 매개 변수를 명시적으로 포함 하는 경우 method 대리자는 개방형 인스턴스 메서드를 나타내는 것으로 간주 됩니다.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. 대리자가 호출 되 면 인수 목록의 첫 번째 인수가의 숨겨진 인스턴스 매개 변수로 전달 됩니다 method .When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • 의 시그니처와 일치 하는 경우 method type (즉, 모든 매개 변수 형식이 호환 되는 경우) 대리자가 null 참조에 대해 닫혀야 합니다.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. 대리자를 호출 하는 것은 null 인스턴스에서 인스턴스 메서드를 호출 하는 것과 같습니다 .이는 특히 유용 하지 않습니다.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

firstArgument가 null 참조이 고 method 정적 이면 결과는 대리자 형식 및의 시그니처에 따라 달라 집니다 type method .If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • 및의 시그니처와 일치 하는 경우 method type (즉, 모든 매개 변수 형식이 호환 되는 경우) 대리자가 개방형 정적 메서드를 나타내는 것으로 간주 됩니다.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. 이는 정적 메서드의 가장 일반적인 경우입니다.This is the most common case for static methods. 이 경우 메서드 오버 로드를 사용 하 여 약간 더 나은 성능을 얻을 수 있습니다 CreateDelegate(Type, MethodInfo, Boolean) .In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo, Boolean) method overload.

  • 의 시그니처가 type 의 두 번째 매개 변수로 시작 method 하 고 나머지 매개 변수 형식이 호환 되는 경우에는 대리자가 null 참조를 사용 하 여 닫혀 있다고 합니다.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. 대리자가 호출 되 면 null 참조는의 첫 번째 매개 변수로 전달 됩니다 method .When the delegate is invoked, a null reference is passed to the first parameter of method.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

호환 되는 매개 변수 형식 및 반환 형식Compatible Parameter Types and Return Type

대리자의 매개 변수 형식 및 반환 형식은 대리자가 나타내는 메서드의 매개 변수 형식 및 반환 형식과 호환 되어야 합니다. 형식이 정확 하 게 일치 하지 않아도 됩니다.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

참고

.NET Framework 버전 1.0 및 1.1에서는 형식이 정확 하 게 일치 해야 합니다.In the .NET Framework version 1.0 and 1.1 the types must match exactly.

대리자 매개 변수의 형식이 메서드 매개 변수의 형식보다 제한적인 경우 대리자의 매개 변수는 메서드의 해당 매개 변수와 호환됩니다. 이 경우 대리자로 전달된 인수를 안전하게 메서드로 전달할 수 있습니다.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

마찬가지로 메서드의 반환 형식이 대리자의 반환 형식보다 제한적인 경우 대리자의 반환 형식은 메서드의 반환 형식과 호환됩니다. 이 경우 메서드의 반환 값을 안전하게 대리자의 반환 형식으로 캐스팅할 수 있습니다.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

예를 들어 형식의 매개 변수 Hashtable 및의 반환 형식이 있는 대리자는 Object 형식의 매개 변수와 형식의 반환 값이 있는 메서드를 나타낼 수 있습니다 Object Hashtable .For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

대리자가 나타낼 수 있는 메서드 확인Determining the Methods a Delegate Can Represent

이 오버 로드를 통해 제공 되는 유연성을 고려 하는 또 다른 유용한 방법은 CreateDelegate 지정 된 모든 대리자가 메서드 시그니처와 메서드 종류 (정적 및 인스턴스)의 네 가지 조합을 나타낼 수 있다는 것입니다.Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). D형식의 인수 하나를 사용 하는 대리자 형식을 고려 C 합니다.Consider a delegate type D with one argument of type C. 다음은 D 모든 경우에 일치 해야 하므로 반환 형식을 무시 하 고 메서드를 나타낼 수 있는 방법에 대해 설명 합니다.The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • DC 인스턴스 메서드가 속한 형식에 관계 없이 형식의 인수를 정확히 한 개 포함 하는 모든 인스턴스 메서드를 나타낼 수 있습니다.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. 가 호출 되는 경우는 해당 CreateDelegate firstArgument 형식의 인스턴스가 method 속하는이 고, 결과 대리자는 해당 인스턴스에 대해 닫혀 있다고 합니다.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (일반적으로 D 는가 인 경우 null 참조를 통해 닫을 수도 firstArgument 있습니다 null .)(Trivially, D can also be closed over a null reference if firstArgument is null.)

  • D 는 인수가 없는의 인스턴스 메서드를 나타낼 수 있습니다 C .D can represent an instance method of C that has no arguments. CreateDelegate가 호출 되 면 firstArgument 는 null 참조입니다.When CreateDelegate is called, firstArgument is a null reference. 결과 대리자는 개방형 인스턴스 메서드를 나타내고 인스턴스는 호출 될 때마다 C 제공 되어야 합니다.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D 는 형식의 인수 하나를 사용 하는 정적 메서드를 나타낼 수 C 있으며 해당 메서드는 모든 형식에 속할 수 있습니다.D can represent a static method that takes one argument of type C, and that method can belong to any type. CreateDelegate가 호출 되 면 firstArgument 는 null 참조입니다.When CreateDelegate is called, firstArgument is a null reference. 결과 대리자는 열려 있는 정적 메서드를 나타내고 인스턴스는 호출 될 때마다 C 제공 되어야 합니다.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D 는 형식에 속하고 형식 F 및 형식의 두 인수를 포함 하는 정적 메서드를 나타낼 수 있습니다 F C .D can represent a static method that belongs to type F and has two arguments, of type F and type C. CreateDelegate가 호출 되 면 firstArgument 가의 인스턴스입니다 F .When CreateDelegate is called, firstArgument is an instance of F. 결과 대리자는 해당 인스턴스에 대해 닫혀 있는 정적 메서드를 나타냅니다 F .The resulting delegate represents a static method that is closed over that instance of F. FC 가 동일한 형식인 경우 정적 메서드에는 해당 형식의 인수가 두 개 있습니다.Note that in the case where F and C are the same type, the static method has two arguments of that type. 이 경우가 인 D 경우 null 참조에 대해가 닫힙니다 firstArgument null .(In this case, D is closed over a null reference if firstArgument is null.)

추가 정보

적용 대상

CreateDelegate(Type, Object, String, Boolean, Boolean)

지정한 대/소문자 구분과 바인딩 실패 시 지정한 동작을 기반으로 지정한 클래스 인스턴스에서 호출하는 지정한 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate? CreateDelegate (Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * string * bool * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Object, method As String, ignoreCase As Boolean, throwOnBindFailure As Boolean) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Object

method가 호출되는 클래스 인스턴스입니다.The class instance on which method is invoked.

method
String

대리자가 나타내는 인스턴스 메서드의 이름입니다.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

메서드의 이름을 비교할 때 대/소문자 구분을 무시할지를 나타내는 부울입니다.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

method를 바인딩할 수 없습니다. 예외가 발생하면 true이고, 예외가 발생하지 않으면 false입니다.true to throw an exception if method cannot be bound; otherwise, false.

반환

Delegate

지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method는 인스턴스 메서드가 아닙니다.method is not an instance method.

또는-or- 예를 들어 찾을 수 없고 throwOnBindFailuretrue이기 때문에 method를 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 인스턴스 메서드에만 대리자를 만듭니다.This method creates delegates for instance methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, MethodInfo, Boolean)

바인딩 실패 시 지정한 동작을 기반으로 지정한 정적 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Reflection::MethodInfo ^ method, bool throwOnBindFailure);
public static Delegate? CreateDelegate (Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * System.Reflection.MethodInfo * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, method As MethodInfo, throwOnBindFailure As Boolean) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

method
MethodInfo

대리자가 나타내는 정적 또는 인스턴스 메서드를 설명하는 MethodInfo입니다.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

method를 바인딩할 수 없습니다. 예외가 발생하면 true이고, 예외가 발생하지 않으면 false입니다.true to throw an exception if method cannot be bound; otherwise, false.

반환

Delegate

지정된 정적 메서드를 나타내기 위한 지정된 형식의 대리자입니다.A delegate of the specified type to represent the specified static method.

예외

type이(가) null인 경우type is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method를 바인딩할 수 없으므로 throwOnBindFailuretrue입니다.method cannot be bound, and throwOnBindFailure is true.

또는-or- method이(가) RuntimeMethodInfo가 아닌 경우method is not a RuntimeMethodInfo. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

예제

이 섹션에는 두 코드 예제가 있습니다.This section contains two code examples. 첫 번째 예제에서는이 메서드 오버 로드를 사용 하 여 만들 수 있는 두 가지 대리자를 보여 줍니다. 인스턴스 메서드를 열고 정적 메서드를 엽니다.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

두 번째 코드 예제에서는 호환 되는 매개 변수 형식 및 반환 형식을 보여 줍니다.The second code example demonstrates compatible parameter types and return types.

예제 1Example 1

다음 코드 예제에서는 메서드의이 오버 로드를 사용 하 여 대리자를 만들 수 있는 두 가지 방법을 보여 줍니다 CreateDelegate .The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

참고

CreateDelegate에는 첫 번째 인수를 지정 하는 것이 아니라를 지정 하는 두 개의 오버 로드가 있습니다 MethodInfo . 해당 기능은 동일 합니다. 단, 바인딩 실패 시 throw 할지 여부를 지정할 수 있도록 하 고 다른 하나는 항상 throw 합니다.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

이 예제에서는 C 정적 메서드 및 인스턴스 메서드를 사용 하 여 클래스를 선언 하 고 M2 M1 , 두 개의 대리자 형식을 사용 합니다 .는 D1 인스턴스 C 및 문자열을 사용 하 고 D2 문자열을 사용 합니다.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

이라는 두 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A second class named Example contains the code that creates the delegates.

  • D1인스턴스 메서드에 대해 개방형 인스턴스 메서드를 나타내는 형식의 대리자가 만들어집니다 M1 .A delegate of type D1, representing an open instance method, is created for the instance method M1. 대리자가 호출 될 때 인스턴스를 전달 해야 합니다.An instance must be passed when the delegate is invoked.

  • D2정적 메서드에 대해 개방형 정적 메서드를 나타내는 형식의 대리자가 만들어집니다 M2 .A delegate of type D2, representing an open static method, is created for the static method M2.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s)
    {
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }

    public static void M2(string s)
    {
        Console.WriteLine("Static method M2 on C:  s = {0}", s);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1",
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;

        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test =
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for
        // example, if mi1 happened to represent a method of
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }

        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");

        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method.
        //
        d2("Hello, World!");
        d2("Hi, Mom!");

        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and
        // the delegate is bound to this string. Use delegate type
        // D3 with static method M2.
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3),
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
'

예제 2Example 2

다음 코드 예제에서는 매개 변수 형식 및 반환 형식의 호환성을 보여 줍니다.The following code example demonstrates compatibility of parameter types and return types.

참고

이 코드 예제에서는 CreateDelegate(Type, MethodInfo) 메서드 오버 로드를 사용 합니다.This code example uses the CreateDelegate(Type, MethodInfo) method overload. 에서 사용 하는 다른 오버 로드를 사용 하는 것 MethodInfo 도 유사 합니다.The use of other overloads that take MethodInfo is similar.

코드 예제에서는 라는 기본 클래스 BaseDerived 에서 파생 되는 이라는 클래스를 정의 합니다 Base .The code example defines a base class named Base and a class named Derived that derives from Base. 파생 클래스에는 static Shared MyMethod 형식의 매개 변수 하 나와 Base 의 반환 형식으로 명명 된 (Visual Basic) 메서드가 있습니다 Derived .The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. 또한 코드 예제에서는 Example 형식의 매개 변수 하 나와의 반환 형식을 포함 하는 라는 대리자를 정의 합니다 Derived Base .The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

이 코드 예제에서는 라는 대리자를 사용 하 여 메서드를 나타낼 수 있음을 보여 줍니다 Example MyMethod .The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. 메서드를 대리자에 바인딩할 수 있는 이유는 다음과 같습니다.The method can be bound to the delegate because:

  • 대리자의 매개 변수 형식 ( Derived )은 MyMethod Base 대리자의 인수를에 전달 하는 것이 항상 안전 하도록 ()의 매개 변수 형식 보다 더 제한적입니다 MyMethod .The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • 메서드의 반환 형식을 MyMethod Derived Base 대리자의 반환 형식으로 캐스팅 하는 것은 항상 안전 하기 때문에 ()의 반환 형식은 대리자의 매개 변수 형식 () 보다 더 제한적입니다.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

코드 예제에서는 출력을 생성 하지 않습니다.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base).
        //
        Example ex =
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //
        Base b = ex(new Derived());
    }
}
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

설명

이 메서드 오버 로드는 개방형 정적 메서드 대리자를 만들고 인스턴스 메서드 대리자를 열 수 있습니다. 즉, 인스턴스 메서드의 숨겨진 첫 번째 인수를 노출 하는 대리자를 만들 수 있습니다.This method overload can create open static method delegates and open instance method delegates - that is, delegates that expose the hidden first argument of instance methods. 자세한 내용은 CreateDelegate(Type, Object, MethodInfo, Boolean) 인스턴스 또는 정적 메서드에 대 한 개방형 또는 폐쇄형 대리자의 모든 조합을 만들 수 있도록 하는 보다 일반적인 메서드 오버 로드를 참조 하세요.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo, Boolean) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods.

참고

이 메서드 오버 로드는 첫 번째 인수에 대해 대리자가 닫혀 있지 않을 때 사용 해야 합니다 .이 경우에는이 경우 약간 더 빠릅니다.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

호환 되는 매개 변수 형식 및 반환 형식Compatible Parameter Types and Return Type

대리자의 매개 변수 형식 및 반환 형식은 대리자가 나타내는 메서드의 매개 변수 형식 및 반환 형식과 호환 되어야 합니다. 형식이 정확 하 게 일치 하지 않아도 됩니다.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

참고

.NET Framework 버전 1.0 및 1.1에서는 형식이 정확 하 게 일치 해야 합니다.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

대리자 매개 변수의 형식이 메서드 매개 변수의 형식보다 제한적인 경우 대리자의 매개 변수는 메서드의 해당 매개 변수와 호환됩니다. 이 경우 대리자로 전달된 인수를 안전하게 메서드로 전달할 수 있습니다.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

마찬가지로 메서드의 반환 형식이 대리자의 반환 형식보다 제한적인 경우 대리자의 반환 형식은 메서드의 반환 형식과 호환됩니다. 이 경우 메서드의 반환 값을 안전하게 대리자의 반환 형식으로 캐스팅할 수 있습니다.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

예를 들어 형식의 매개 변수 Hashtable 및의 반환 형식이 있는 대리자는 Object 형식의 매개 변수와 형식의 반환 값이 있는 메서드를 나타낼 수 있습니다 Object Hashtable .For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

추가 정보

적용 대상

CreateDelegate(Type, Object, String)

지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method);
public static Delegate CreateDelegate (Type type, object target, string method);
static member CreateDelegate : Type * obj * string -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Object, method As String) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Object

method가 호출되는 클래스 인스턴스입니다.The class instance on which method is invoked.

method
String

대리자가 나타내는 인스턴스 메서드의 이름입니다.The name of the instance method that the delegate is to represent.

반환

Delegate

지정된 클래스 인스턴스에서 호출하는 지정된 인스턴스 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method는 인스턴스 메서드가 아닙니다.method is not an instance method.

또는-or- 예를 들어 method는 찾을 수 없기 때문에 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 인스턴스 메서드에만 대리자를 만듭니다.This method creates delegates for instance methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

이 메서드 오버 로드는 메서드 오버 로드를 호출 하는 것과 같으며에 대해 CreateDelegate(Type, Object, String, Boolean, Boolean) 및를 지정 false ignoreCase true throwOnBindFailure 합니다.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, Object, MethodInfo)

지정한 첫 번째 인수를 사용하여 지정한 정적 또는 인스턴스 메서드를 나타내는 지정한 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ firstArgument, System::Reflection::MethodInfo ^ method);
public static Delegate CreateDelegate (Type type, object? firstArgument, System.Reflection.MethodInfo method);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo -> Delegate
Public Shared Function CreateDelegate (type As Type, firstArgument As Object, method As MethodInfo) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

firstArgument
Object

대리자가 바인드되는 개체이거나, methodstatic(Visual Basic의 경우 Shared)으로 처리하는 경우 null입니다.The object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo

대리자가 나타내는 정적 또는 인스턴스 메서드를 설명하는 MethodInfo입니다.The MethodInfo describing the static or instance method the delegate is to represent.

반환

Delegate

지정된 정적 또는 인스턴스 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified static or instance method.

예외

type이(가) null인 경우type is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method를 바인딩할 수 없습니다.method cannot be bound.

또는-or- method이(가) RuntimeMethodInfo가 아닌 경우method is not a RuntimeMethodInfo. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

예제

이 섹션에는 세 가지 코드 예제가 있습니다.This section contains three code examples. 첫 번째 예제에서는 생성 될 수 있는 네 가지 종류의 대리자 (인스턴스 메서드를 통해 닫힘, 인스턴스 메서드를 통해 열기, 정적 메서드를 통해 열기 및 정적 메서드를 통해 닫힘)를 보여 줍니다.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

두 번째 코드 예제에서는 호환 되는 매개 변수 형식 및 반환 형식을 보여 줍니다.The second code example demonstrates compatible parameter types and return types.

세 번째 코드 예제에서는 단일 대리자 형식을 정의 하 고 대리자 형식이 나타낼 수 있는 모든 메서드를 보여 줍니다.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

예제 1Example 1

다음 코드 예제에서는 메서드의이 오버 로드를 사용 하 여 대리자를 만들 수 있는 네 가지 방법을 보여 줍니다 CreateDelegate .The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

참고

및를 지정 하는 메서드의 오버 로드에는 두 가지가 있습니다 CreateDelegate firstArgument MethodInfo . 즉, 바인딩 실패 시 throw 여부를 지정 하는 것을 허용 하 고 다른 하나는 항상 throw 한다는 점을 제외 하 고는 동일 합니다.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

예제에서는 C 정적 메서드 및 인스턴스 메서드를 사용 하 여 클래스를 선언 M2 M1 하 고, 세 개의 대리자 형식으로 인스턴스를 사용 하 고 문자열을 사용 D1 C D2 하며 문자열을 사용 하 고 인수를 사용 D3 하지 않습니다.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

이라는 두 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A second class named Example contains the code that creates the delegates.

  • 인스턴스에 대해 닫혀 있는 형식의 대리자 D2 C 가 인스턴스 메서드에 대해 만들어집니다 M1 .A delegate of type D2, closed over an instance of C, is created for the instance method M1. 의 바인딩된 인스턴스가 항상 사용 됨을 보여 주기 위해 다른 문자열로 호출 됩니다 C .It is invoked with different strings, to show that the bound instance of C is always used.

  • D1인스턴스 메서드에 대해 개방형 인스턴스 메서드를 나타내는 형식의 대리자가 만들어집니다 M1 .A delegate of type D1, representing an open instance method, is created for the instance method M1. 대리자가 호출 될 때 인스턴스를 전달 해야 합니다.An instance must be passed when the delegate is invoked.

  • D2정적 메서드에 대해 개방형 정적 메서드를 나타내는 형식의 대리자가 만들어집니다 M2 .A delegate of type D2, representing an open static method, is created for the static method M2.

  • 마지막으로 D3 , 문자열에 대해 폐쇄형 형식의 대리자가 정적 메서드에 대해 만들어집니다 M2 .Finally, a delegate of type D3, closed over a string, is created for the static method M2. 바인딩된 문자열을 사용 함을 표시 하기 위해 메서드가 호출 됩니다.The method is invoked to show that it uses the bound string.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s)
    {
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }

    public static void M2(string s)
    {
        Console.WriteLine("Static method M2 on C:  s = {0}", s);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1",
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;

        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test =
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for
        // example, if mi1 happened to represent a method of
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }

        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");

        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method.
        //
        d2("Hello, World!");
        d2("Hi, Mom!");

        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and
        // the delegate is bound to this string. Use delegate type
        // D3 with static method M2.
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3),
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
'

예제 2Example 2

다음 코드 예제에서는 매개 변수 형식 및 반환 형식의 호환성을 보여 줍니다.The following code example demonstrates compatibility of parameter types and return types.

참고

이 코드 예제에서는 CreateDelegate(Type, MethodInfo) 메서드 오버 로드를 사용 합니다.This code example uses the CreateDelegate(Type, MethodInfo) method overload. 에서 사용 하는 다른 오버 로드를 사용 하는 것 MethodInfo 도 유사 합니다.The use of other overloads that take MethodInfo is similar.

코드 예제에서는 라는 기본 클래스 BaseDerived 에서 파생 되는 이라는 클래스를 정의 합니다 Base .The code example defines a base class named Base and a class named Derived that derives from Base. 파생 클래스에는 static Shared MyMethod 형식의 매개 변수 하 나와 Base 의 반환 형식으로 명명 된 (Visual Basic) 메서드가 있습니다 Derived .The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. 또한 코드 예제에서는 Example 형식의 매개 변수 하 나와의 반환 형식을 포함 하는 라는 대리자를 정의 합니다 Derived Base .The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

이 코드 예제에서는 라는 대리자를 사용 하 여 메서드를 나타낼 수 있음을 보여 줍니다 Example MyMethod .The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. 메서드를 대리자에 바인딩할 수 있는 이유는 다음과 같습니다.The method can be bound to the delegate because:

  • 대리자의 매개 변수 형식 ( Derived )은 MyMethod Base 대리자의 인수를에 전달 하는 것이 항상 안전 하도록 ()의 매개 변수 형식 보다 더 제한적입니다 MyMethod .The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • 메서드의 반환 형식을 MyMethod Derived Base 대리자의 반환 형식으로 캐스팅 하는 것은 항상 안전 하기 때문에 ()의 반환 형식은 대리자의 매개 변수 형식 () 보다 더 제한적입니다.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

코드 예제에서는 출력을 생성 하지 않습니다.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base).
        //
        Example ex =
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //
        Base b = ex(new Derived());
    }
}
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

예 3Example 3

다음 코드 예제에서는 메서드를 사용 하 여 대리자를 만드는 단일 대리자 형식이 나타낼 수 있는 모든 메서드를 보여 줍니다 CreateDelegate .The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

참고

및를 지정 하는 메서드의 오버 로드에는 두 가지가 있습니다 CreateDelegate firstArgument MethodInfo . 즉, 바인딩 실패 시 throw 여부를 지정 하는 것을 허용 하 고 다른 하나는 항상 throw 한다는 점을 제외 하 고는 동일 합니다.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

이 코드 예제에서는 두 클래스 CF 를 정의 하 고 D 형식의 인수 하나를 사용 하는 대리자 형식을 정의 합니다 C .The code example defines two classes, C and F, and a delegate type D with one argument of type C. 클래스에 일치 하는 정적 및 인스턴스 메서드, 및이 있고 M1 M3 클래스에 M4 C 도 인수가 없는 인스턴스 메서드가 있습니다 M2 .The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

이라는 세 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A third class named Example contains the code that creates the delegates.

  • 대리자는 형식 및 형식의 인스턴스 메서드에 대해 만들어지며 M1 C F , 각각은 해당 형식의 인스턴스를 통해 닫힙니다.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. M1형식의 메서드는 C ID 바인딩된 인스턴스와 인수의 속성을 표시 합니다.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • 형식의 메서드에 대 한 대리자가 만들어집니다 M2 C .A delegate is created for method M2 of type C. 이 대리자의 인수는 인스턴스 메서드의 숨겨진 첫 번째 인수를 나타내는 개방형 인스턴스 대리자입니다.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. 메서드에 다른 인수가 없습니다.The method has no other arguments. 정적 메서드인 것 처럼 호출 됩니다.It is called as if it were a static method.

  • 대리자는 형식 및 형식의 정적 메서드에 대해 만들어지므로 M3 C F 개방형 정적 대리자입니다.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • 마지막으로, 형식 및 형식의 정적 메서드에 대 한 대리자가 만들어집니다 M4 C F . 각 메서드는 선언 형식을 첫 번째 인수로 가지 며 형식의 인스턴스가 제공 되므로 첫 번째 인수에 대해 대리자가 닫힙니다.Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. M4형식의 메서드는 C ID 바인딩된 인스턴스와 인수의 속성을 표시 합니다.Method M4 of type C displays the ID properties of the bound instance and of the argument.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
//
public delegate void D(C c);

// Declare two sample classes, C and F. Class C has an ID
// property so instances can be identified.
//
public class C
{
    private int id;
    public int ID { get { return id; }}
    public C(int id) { this.id = id; }

    public void M1(C c)
    {
        Console.WriteLine("Instance method M1(C c) on C:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }

    public void M2()
    {
        Console.WriteLine("Instance method M2() on C:  this.id = {0}",
            this.id);
    }

    public static void M3(C c)
    {
        Console.WriteLine("Static method M3(C c) on C:  c.ID = {0}", c.ID);
    }

    public static void M4(C c1, C c2)
    {
        Console.WriteLine("Static method M4(C c1, C c2) on C:  c1.ID = {0}, c2.ID = {1}",
            c1.ID, c2.ID);
    }
}

public class F
{
    public void M1(C c)
    {
        Console.WriteLine("Instance method M1(C c) on F:  c.ID = {0}",
            c.ID);
    }

    public static void M3(C c)
    {
        Console.WriteLine("Static method M3(C c) on F:  c.ID = {0}", c.ID);
    }

    public static void M4(F f, C c)
    {
        Console.WriteLine("Static method M4(F f, C c) on F:  c.ID = {0}",
            c.ID);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);
        C c2 = new C(1491);
        F f1 = new F();

        D d;

        // Instance method with one argument of type C.
        MethodInfo cmi1 = typeof(C).GetMethod("M1");
        // Instance method with no arguments.
        MethodInfo cmi2 = typeof(C).GetMethod("M2");
        // Static method with one argument of type C.
        MethodInfo cmi3 = typeof(C).GetMethod("M3");
        // Static method with two arguments of type C.
        MethodInfo cmi4 = typeof(C).GetMethod("M4");

        // Instance method with one argument of type C.
        MethodInfo fmi1 = typeof(F).GetMethod("M1");
        // Static method with one argument of type C.
        MethodInfo fmi3 = typeof(F).GetMethod("M3");
        // Static method with an argument of type F and an argument
        // of type C.
        MethodInfo fmi4 = typeof(F).GetMethod("M4");

        Console.WriteLine("\nAn instance method on any type, with an argument of type C.");
        // D can represent any instance method that exactly matches its
        // signature. Methods on C and F are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi1);
        d(c2);
        d = (D) Delegate.CreateDelegate(typeof(D), f1, fmi1);
        d(c2);

        Console.WriteLine("\nAn instance method on C with no arguments.");
        // D can represent an instance method on C that has no arguments;
        // in this case, the argument of D represents the hidden first
        // argument of any instance method. The delegate acts like a
        // static method, and an instance of C must be passed each time
        // it is invoked.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi2);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of type C.");
        // D can represent any static method with the same signature.
        // Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi3);
        d(c1);
        d = (D) Delegate.CreateDelegate(typeof(D), null, fmi3);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of");
        Console.WriteLine("    that type and an argument of type C.");
        // D can represent any static method with one argument of the
        // type the method belongs and a second argument of type C.
        // In this case, the method is closed over the instance of
        // supplied for the its first argument, and acts like an instance
        // method. Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi4);
        d(c2);
        Delegate test =
            Delegate.CreateDelegate(typeof(D), f1, fmi4, false);

        // This final example specifies false for throwOnBindFailure
        // in the call to CreateDelegate, so the variable 'test'
        // contains Nothing if the method fails to bind (for
        // example, if fmi4 happened to represent a method of
        // some class other than F).
        //
        if (test != null)
        {
            d = (D) test;
            d(c2);
        }
    }
}

/* This code example produces the following output:

An instance method on any type, with an argument of type C.
Instance method M1(C c) on C:  this.id = 42, c.ID = 1491
Instance method M1(C c) on F:  c.ID = 1491

An instance method on C with no arguments.
Instance method M2() on C:  this.id = 42

A static method on any type, with an argument of type C.
Static method M3(C c) on C:  c.ID = 42
Static method M3(C c) on F:  c.ID = 42

A static method on any type, with an argument of
    that type and an argument of type C.
Static method M4(C c1, C c2) on C:  c1.ID = 42, c2.ID = 1491
Static method M4(F f, C c) on F:  c.ID = 1491
*/
Imports System.Reflection
Imports System.Security.Permissions

' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C) 

' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C

    Private _id As Integer

    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property

    Public Sub New(ByVal newId As Integer) 
        Me._id = newId
    End Sub
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
            Me.id, c.ID)
    End Sub
    
    Public Sub M2() 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
        Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
            c1.ID, c2.ID)
    End Sub
End Class


Public Class F
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal f As F, ByVal c As C) 
        Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        Dim c2 As New C(1491)
        Dim f1 As New F()
        
        Dim d As D
        
        ' Instance method with one argument of type C.
        Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
        ' Instance method with no arguments.
        Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
        ' Shared method with one argument of type C.
        Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
        ' Shared method with two arguments of type C.
        Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
        
        ' Instance method with one argument of type C.
        Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
        ' Shared method with one argument of type C.
        Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
        ' Shared method with an argument of type F and an 
        ' argument of type C.
        Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
        
        Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
        ' D can represent any instance method that exactly matches its
        ' signature. Methods on C and F are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
        d(c2)
        d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
        d(c2)
        
        Console.WriteLine(vbLf & "An instance method on C with no arguments.")
        ' D can represent an instance method on C that has no arguments;
        ' in this case, the argument of D represents the hidden first
        ' argument of any instance method. The delegate acts like a 
        ' Shared method, and an instance of C must be passed each time
        ' it is invoked.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
        ' D can represent any Shared method with the same signature.
        ' Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
        d(c1)
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
        Console.WriteLine("    that type and an argument of type C.")
        ' D can represent any Shared method with one argument of the
        ' type the method belongs and a second argument of type C.
        ' In this case, the method is closed over the instance of
        ' supplied for the its first argument, and acts like an instance
        ' method. Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
        d(c2)
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D), f1, fmi4, false)

        ' This final example specifies False for throwOnBindFailure 
        ' in the call to CreateDelegate, so the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if fmi4 happened to represent a method of  
        ' some class other than F).
        '
        If test IsNot Nothing Then
            d = CType(test, D)
            d(c2)
        End If
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C:  this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F:  c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C:  this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C:  c.ID = 42
'Shared method M3(c As C) on F:  c.ID = 42
'
'A Shared method on any type, with an argument of
'    that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C:  c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F:  c.ID = 1491
'

설명

이 메서드 오버 로드를 호출 하는 것은 CreateDelegate(Type, Object, MethodInfo, Boolean) 메서드 오버 로드를 호출 하 고를 지정 하는 것과 같습니다 true throwOnBindFailureCalling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. 이러한 두 오버 로드는 대리자를 만드는 가장 유연한 방법을 제공 합니다.These two overloads provide the most flexible way to create delegates. 이러한 메서드를 사용 하 여 정적 또는 인스턴스 메서드에 대 한 대리자를 만들고 필요에 따라 첫 번째 인수를 지정할 수 있습니다.You can use them to create delegates for either static or instance methods, and optionally to specify the first argument.

참고

첫 번째 인수를 제공 하지 않으면 CreateDelegate(Type, MethodInfo) 성능 향상을 위해 메서드 오버 로드를 사용 합니다.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo) method overload for better performance.

대리자 형식과 메서드에 호환 되는 반환 형식이 있어야 합니다.The delegate type and the method must have compatible return types. 즉,의 반환 형식을 method 의 반환 형식에 할당할 수 있어야 합니다 type .That is, the return type of method must be assignable to the return type of type.

가 제공 되는 경우 대리자가 호출 될 때마다 firstArgument 로 전달 되 고, method firstArgument 는 대리자에 바인딩되고, 대리자는 첫 번째 인수에 대해 닫혀 있다고 합니다.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. methodstatic (Visual Basic) 인 경우 Shared 대리자를 호출할 때 제공 되는 인수 목록에는 첫 번째를 제외한 모든 매개 변수가 포함 됩니다. method 가 인스턴스 메서드인 경우 firstArgument 는 숨겨진 인스턴스 매개 변수로 전달 됩니다 ( this c #의 경우 또는 Me Visual Basic에서로 나타냄).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

를 제공 하는 경우 firstArgument 의 첫 번째 매개 변수는 method 참조 형식 이어야 하 고 firstArgument 해당 형식과 호환 되어야 합니다.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

중요

methodstatic ( Shared Visual Basic)이 고 첫 번째 매개 변수가 또는 형식이 면는 Object ValueType firstArgument 값 형식일 수 있습니다.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. 이 경우 firstArgument 자동으로 boxing 됩니다.In this case firstArgument is automatically boxed. C # 또는 Visual Basic 함수 호출 에서처럼 다른 인수에 대해서는 자동 boxing이 발생 하지 않습니다.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

firstArgument가 null 참조이 고 method 가 인스턴스 메서드인 경우 결과는 대리자 형식 및의 시그니처에 따라 달라 집니다 type method .If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • 의 시그니처에서 type 의 숨겨진 첫 번째 매개 변수를 명시적으로 포함 하는 경우 method 대리자는 개방형 인스턴스 메서드를 나타내는 것으로 간주 됩니다.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. 대리자가 호출 되 면 인수 목록의 첫 번째 인수가의 숨겨진 인스턴스 매개 변수로 전달 됩니다 method .When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • 의 시그니처와 일치 하는 경우 method type (즉, 모든 매개 변수 형식이 호환 되는 경우) 대리자가 null 참조에 대해 닫혀야 합니다.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. 대리자를 호출 하는 것은 null 인스턴스에서 인스턴스 메서드를 호출 하는 것과 같습니다 .이는 특히 유용 하지 않습니다.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

firstArgument가 null 참조이 고 method 정적 이면 결과는 대리자 형식 및의 시그니처에 따라 달라 집니다 type method .If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • 및의 시그니처와 일치 하는 경우 method type (즉, 모든 매개 변수 형식이 호환 되는 경우) 대리자가 개방형 정적 메서드를 나타내는 것으로 간주 됩니다.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. 이는 정적 메서드의 가장 일반적인 경우입니다.This is the most common case for static methods. 이 경우 메서드 오버 로드를 사용 하 여 약간 더 나은 성능을 얻을 수 있습니다 CreateDelegate(Type, MethodInfo) .In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo) method overload.

  • 의 시그니처가 type 의 두 번째 매개 변수로 시작 method 하 고 나머지 매개 변수 형식이 호환 되는 경우에는 대리자가 null 참조를 사용 하 여 닫혀 있다고 합니다.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. 대리자가 호출 되 면 null 참조는의 첫 번째 매개 변수로 전달 됩니다 method .When the delegate is invoked, a null reference is passed to the first parameter of method.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

호환 되는 매개 변수 형식 및 반환 형식Compatible Parameter Types and Return Type

대리자의 매개 변수 형식 및 반환 형식은 대리자가 나타내는 메서드의 매개 변수 형식 및 반환 형식과 호환 되어야 합니다. 형식이 정확 하 게 일치 하지 않아도 됩니다.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

참고

.NET Framework 버전 1.0 및 1.1에서는 형식이 정확 하 게 일치 해야 합니다.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

대리자 매개 변수의 형식이 메서드 매개 변수의 형식보다 제한적인 경우 대리자의 매개 변수는 메서드의 해당 매개 변수와 호환됩니다. 이 경우 대리자로 전달된 인수를 안전하게 메서드로 전달할 수 있습니다.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

마찬가지로 메서드의 반환 형식이 대리자의 반환 형식보다 제한적인 경우 대리자의 반환 형식은 메서드의 반환 형식과 호환됩니다. 이 경우 메서드의 반환 값을 안전하게 대리자의 반환 형식으로 캐스팅할 수 있습니다.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

예를 들어 형식의 매개 변수 Hashtable 및의 반환 형식이 있는 대리자는 Object 형식의 매개 변수와 형식의 반환 값이 있는 메서드를 나타낼 수 있습니다 Object Hashtable .For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

대리자가 나타낼 수 있는 메서드 확인Determining the Methods a Delegate Can Represent

이 오버 로드를 통해 제공 되는 유연성을 고려 하는 또 다른 유용한 방법은 CreateDelegate 지정 된 모든 대리자가 메서드 시그니처와 메서드 종류 (정적 및 인스턴스)의 네 가지 조합을 나타낼 수 있다는 것입니다.Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). D형식의 인수 하나를 사용 하는 대리자 형식을 고려 C 합니다.Consider a delegate type D with one argument of type C. 다음은 D 모든 경우에 일치 해야 하므로 반환 형식을 무시 하 고 메서드를 나타낼 수 있는 방법에 대해 설명 합니다.The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • DC 인스턴스 메서드가 속한 형식에 관계 없이 형식의 인수를 정확히 한 개 포함 하는 모든 인스턴스 메서드를 나타낼 수 있습니다.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. 가 호출 되는 경우는 해당 CreateDelegate firstArgument 형식의 인스턴스가 method 속하는이 고, 결과 대리자는 해당 인스턴스에 대해 닫혀 있다고 합니다.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (일반적으로는 D 가 null 참조 인 경우 null 참조에 대해 닫을 수도 있습니다 firstArgument .)(Trivially, D can also be closed over a null reference if firstArgument is a null reference.)

  • D 는 인수가 없는의 인스턴스 메서드를 나타낼 수 있습니다 C .D can represent an instance method of C that has no arguments. CreateDelegate가 호출 되 면 firstArgument 는 null 참조입니다.When CreateDelegate is called, firstArgument is a null reference. 결과 대리자는 개방형 인스턴스 메서드를 나타내고 인스턴스는 호출 될 때마다 C 제공 되어야 합니다.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D 는 형식의 인수 하나를 사용 하는 정적 메서드를 나타낼 수 C 있으며 해당 메서드는 모든 형식에 속할 수 있습니다.D can represent a static method that takes one argument of type C, and that method can belong to any type. CreateDelegate가 호출 되 면 firstArgument 는 null 참조입니다.When CreateDelegate is called, firstArgument is a null reference. 결과 대리자는 열려 있는 정적 메서드를 나타내고 인스턴스는 호출 될 때마다 C 제공 되어야 합니다.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D 는 형식에 속하고 형식 F 및 형식의 두 인수를 포함 하는 정적 메서드를 나타낼 수 있습니다 F C .D can represent a static method that belongs to type F and has two arguments, of type F and type C. CreateDelegate가 호출 되 면 firstArgument 가의 인스턴스입니다 F .When CreateDelegate is called, firstArgument is an instance of F. 결과 대리자는 해당 인스턴스에 대해 닫혀 있는 정적 메서드를 나타냅니다 F .The resulting delegate represents a static method that is closed over that instance of F. FC 가 동일한 형식인 경우 정적 메서드에는 해당 형식의 인수가 두 개 있습니다.Note that in the case where F and C are the same type, the static method has two arguments of that type. 이 경우은 null 참조 D 에 대해 닫혀 firstArgument 있습니다 (가 null 참조 인 경우).(In this case, D is closed over a null reference if firstArgument is a null reference.)

추가 정보

적용 대상

CreateDelegate(Type, Type, String)

지정된 클래스의 지정된 정적 메서드를 나타내는 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type that represents the specified static method of the specified class.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method);
public static Delegate CreateDelegate (Type type, Type target, string method);
static member CreateDelegate : Type * Type * string -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Type, method As String) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

target
Type

method를 구현하는 클래스를 나타내는 Type입니다.The Type representing the class that implements method.

method
String

대리자가 나타내는 정적 메서드의 이름입니다.The name of the static method that the delegate is to represent.

반환

Delegate

지정된 클래스의 지정된 정적 메서드를 나타내는 지정된 형식의 대리자입니다.A delegate of the specified type that represents the specified static method of the specified class.

예외

type이(가) null인 경우type is null.

-또는--or- targetnull입니다.target is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- target이(가) RuntimeType가 아닌 경우target is not a RuntimeType.

또는-or- target이 개방형 제네릭 형식인 경우.target is an open generic type. 즉, 해당 ContainsGenericParameters 속성이 true인 경우That is, its ContainsGenericParameters property is true.

또는-or- methodstatic 메서드(Visual Basic의 경우 Shared 메서드)가 아닌 경우method is not a static method (Shared method in Visual Basic).

또는-or- 예를 들어 찾을 수 없고 throwOnBindFailuretrue이기 때문에 method를 바인딩할 수 없습니다.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

설명

이 메서드는 정적 메서드에만 대리자를 만듭니다.This method creates delegates for static methods only. 인스턴스 메서드는 클래스의 인스턴스와 연결 된 메서드입니다. 정적 메서드는 클래스 자체와 연결 된 메서드입니다.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

이 메서드 오버 로드는 메서드 오버 로드를 호출 하는 것과 같으며에 대해 CreateDelegate(Type, Type, String, Boolean, Boolean) 및를 지정 false ignoreCase true throwOnBindFailure 합니다.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

추가 정보

적용 대상

CreateDelegate(Type, MethodInfo)

지정된 정적 메서드를 나타내기 위해서 지정된 형식의 대리자를 만듭니다.Creates a delegate of the specified type to represent the specified static method.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Reflection::MethodInfo ^ method);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method);
static member CreateDelegate : Type * System.Reflection.MethodInfo -> Delegate
Public Shared Function CreateDelegate (type As Type, method As MethodInfo) As Delegate

매개 변수

type
Type

만들 대리자의 Type입니다.The Type of delegate to create.

method
MethodInfo

대리자가 나타내는 정적 또는 인스턴스 메서드를 설명하는 MethodInfo입니다.The MethodInfo describing the static or instance method the delegate is to represent. .NET Framework 버전 1.0 및 1.1에서는 정적 메서드만 지원됩니다.Only static methods are supported in the .NET Framework version 1.0 and 1.1.

반환

Delegate

지정된 정적 메서드를 나타내기 위한 지정된 형식의 대리자입니다.A delegate of the specified type to represent the specified static method.

예외

type이(가) null인 경우type is null.

-또는--or- method이(가) null인 경우method is null.

typeMulticastDelegate를 상속하지 않습니다.type does not inherit MulticastDelegate.

또는-or- type이(가) RuntimeType가 아닌 경우type is not a RuntimeType. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

또는-or- method 가 정적 메서드가 아니며 .NET Framework 버전이 1.0 또는 1.1입니다.method is not a static method, and the .NET Framework version is 1.0 or 1.1.

또는-or- method를 바인딩할 수 없습니다.method cannot be bound.

또는-or- method이(가) RuntimeMethodInfo가 아닌 경우method is not a RuntimeMethodInfo. 리플렉션의 런타임 형식을 참조하세요.See Runtime Types in Reflection.

typeInvoke 메서드를 찾을 수 없습니다.The Invoke method of type is not found.

호출자에게 method에 액세스하는 데 필요한 권한이 없습니다.The caller does not have the permissions necessary to access method.

예제

이 섹션에는 두 코드 예제가 있습니다.This section contains two code examples. 첫 번째 예제에서는이 메서드 오버 로드를 사용 하 여 만들 수 있는 두 가지 대리자를 보여 줍니다. 인스턴스 메서드를 열고 정적 메서드를 엽니다.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

두 번째 코드 예제에서는 호환 되는 매개 변수 형식 및 반환 형식을 보여 줍니다.The second code example demonstrates compatible parameter types and return types.

예제 1Example 1

다음 코드 예제에서는 메서드의이 오버 로드를 사용 하 여 대리자를 만들 수 있는 두 가지 방법을 보여 줍니다 CreateDelegate .The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

참고

CreateDelegate에는 첫 번째 인수를 지정 하는 것이 아니라를 지정 하는 두 개의 오버 로드가 있습니다 MethodInfo . 해당 기능은 동일 합니다. 단, 바인딩 실패 시 throw 할지 여부를 지정할 수 있도록 하 고 다른 하나는 항상 throw 합니다.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. 이 코드 예제에서는 두 오버 로드를 모두 사용 합니다.This code example uses both overloads.

이 예제에서는 C 정적 메서드 및 인스턴스 메서드를 사용 하 여 클래스를 선언 하 고 M2 M1 , 두 개의 대리자 형식을 사용 합니다 .는 D1 인스턴스 C 및 문자열을 사용 하 고 D2 문자열을 사용 합니다.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

이라는 두 번째 클래스에는 Example 대리자를 만드는 코드가 포함 되어 있습니다.A second class named Example contains the code that creates the delegates.

  • D1인스턴스 메서드에 대해 개방형 인스턴스 메서드를 나타내는 형식의 대리자가 만들어집니다 M1 .A delegate of type D1, representing an open instance method, is created for the instance method M1. 대리자가 호출 될 때 인스턴스를 전달 해야 합니다.An instance must be passed when the delegate is invoked.

  • D2정적 메서드에 대해 개방형 정적 메서드를 나타내는 형식의 대리자가 만들어집니다 M2 .A delegate of type D2, representing an open static method, is created for the static method M2.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s)
    {
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }

    public static void M2(string s)
    {
        Console.WriteLine("Static method M2 on C:  s = {0}", s);
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1",
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;

        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test =
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for
        // example, if mi1 happened to represent a method of
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }

        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");

        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method.
        //
        d2("Hello, World!");
        d2("Hi, Mom!");

        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and
        // the delegate is bound to this string. Use delegate type
        // D3 with static method M2.
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3),
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
'

예제 2Example 2

다음 코드 예제에서는 매개 변수 형식 및 반환 형식의 호환성을 보여 줍니다.The following code example demonstrates compatibility of parameter types and return types.

코드 예제에서는 라는 기본 클래스 BaseDerived 에서 파생 되는 이라는 클래스를 정의 합니다 Base .The code example defines a base class named Base and a class named Derived that derives from Base. 파생 클래스에는 static Shared MyMethod 형식의 매개 변수 하 나와 Base 의 반환 형식으로 명명 된 (Visual Basic) 메서드가 있습니다 Derived .The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. 또한 코드 예제에서는 Example 형식의 매개 변수 하 나와의 반환 형식을 포함 하는 라는 대리자를 정의 합니다 Derived Base .The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

이 코드 예제에서는 라는 대리자를 사용 하 여 메서드를 나타낼 수 있음을 보여 줍니다 Example MyMethod .The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. 메서드를 대리자에 바인딩할 수 있는 이유는 다음과 같습니다.The method can be bound to the delegate because:

  • 대리자의 매개 변수 형식 ( Derived )은 MyMethod Base 대리자의 인수를에 전달 하는 것이 항상 안전 하도록 ()의 매개 변수 형식 보다 더 제한적입니다 MyMethod .The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • 메서드의 반환 형식을 MyMethod Derived Base 대리자의 반환 형식으로 캐스팅 하는 것은 항상 안전 하기 때문에 ()의 반환 형식은 대리자의 매개 변수 형식 () 보다 더 제한적입니다.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

코드 예제에서는 출력을 생성 하지 않습니다.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base).
        //
        Example ex =
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //
        Base b = ex(new Derived());
    }
}
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

설명

.NET Framework 버전 1.0 및 1.1에서이 메서드 오버 로드는 정적 메서드에만 대리자를 만듭니다.In the .NET Framework version 1.0 and 1.1, this method overload creates delegates for static methods only. .NET Framework 버전 2.0에서이 메서드 오버 로드는 개방형 인스턴스 메서드 대리자를 만들 수도 있습니다. 즉, 인스턴스 메서드의 숨겨진 첫 번째 인수를 명시적으로 제공 하는 대리자입니다.In the .NET Framework version 2.0, this method overload also can create open instance method delegates; that is, delegates that explicitly supply the hidden first argument of instance methods. 자세한 내용은 CreateDelegate(Type, Object, MethodInfo) 인스턴스 또는 정적 메서드에 대 한 개방형 또는 폐쇄형 대리자의 모든 조합을 만들고 선택적으로 첫 번째 인수를 지정 하는 데 사용할 수 있는 보다 일반적인 메서드 오버 로드를 참조 하세요.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods, and optionally to specify a first argument.

참고

이 메서드 오버 로드는 첫 번째 인수에 대해 대리자가 닫혀 있지 않을 때 사용 해야 합니다 .이 경우에는이 경우 약간 더 빠릅니다.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

이 메서드 오버 로드는 CreateDelegate(Type, MethodInfo, Boolean) 메서드 오버 로드를 호출 하 고에 대해를 지정 하는 것과 같습니다 true throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

참고

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

이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this functionality, your application should target the .NET Framework 3.5 or later.

호환 되는 매개 변수 형식 및 반환 형식Compatible Parameter Types and Return Type

.NET Framework 버전 2.0에서이 메서드 오버 로드를 사용 하 여 만든 대리자의 매개 변수 형식 및 반환 형식은 대리자가 나타내는 메서드의 매개 변수 형식 및 반환 형식과 호환 되어야 합니다. 형식이 정확 하 게 일치 하지 않아도 됩니다.In the .NET Framework version 2.0, the parameter types and return type of a delegate created using this method overload must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly. 이는 .NET Framework 버전 1.0 및 1.1에서 바인딩 동작의 완화를 나타내며,이는 형식이 정확 하 게 일치 해야 합니다.This represents a relaxation of the binding behavior in the .NET Framework version 1.0 and 1.1, where the types must match exactly.

대리자 매개 변수의 형식이 메서드 매개 변수의 형식보다 제한적인 경우 대리자의 매개 변수는 메서드의 해당 매개 변수와 호환됩니다. 이 경우 대리자로 전달된 인수를 안전하게 메서드로 전달할 수 있습니다.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

마찬가지로 메서드의 반환 형식이 대리자의 반환 형식보다 제한적인 경우 대리자의 반환 형식은 메서드의 반환 형식과 호환됩니다. 이 경우 메서드의 반환 값을 안전하게 대리자의 반환 형식으로 캐스팅할 수 있습니다.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

예를 들어 형식의 매개 변수 Hashtable 및의 반환 형식이 있는 대리자는 Object 형식의 매개 변수와 형식의 반환 값이 있는 메서드를 나타낼 수 있습니다 Object Hashtable .For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

추가 정보

적용 대상