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)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数およびバインドに失敗したときの動作を指定して作成します。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)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数を指定して作成します。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);
static member CreateDelegate : Type * Type * string * bool * bool -> Delegate

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

target
Type

Type を実装するクラスを表す methodThe 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

true をバインドできないときに例外をスローする場合は method、それ以外の場合は falsetrue to throw an exception if method cannot be bound; otherwise, false.

戻り値

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified static method of the specified class.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- targetRuntimeType ではありません。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 をバインドできません。また、throwOnBindFailuretrue です。method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Invoketype メソッドが見つかりません。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.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

target
Type

Type を実装するクラスを表す methodThe 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.

戻り値

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified static method of the specified class.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- targetRuntimeType ではありません。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.

Invoketype メソッドが見つかりません。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.

このメソッドのオーバーロードは、throwOnBindFailuretrue を指定して CreateDelegate(Type, Type, String, Boolean, Boolean) メソッドのオーバーロードを呼び出すことと同じです。This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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

パラメーター

type
Type

作成するデリゲートの TypeThe 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.

戻り値

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。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.

Invoketype メソッドが見つかりません。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.

このメソッドのオーバーロードは、throwOnBindFailuretrue を指定して CreateDelegate(Type, Object, String, Boolean, Boolean) メソッドのオーバーロードを呼び出すことと同じです。This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

こちらもご覧ください

CreateDelegate(Type, Object, MethodInfo, Boolean)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数およびバインドに失敗したときの動作を指定して作成します。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);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo * bool -> Delegate

パラメーター

type
Type

作成するデリゲートの型を表す TypeA Type representing the type of delegate to create.

firstArgument
Object

デリゲートが表すメソッドの第 1 引数である ObjectAn 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

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を保持する MethodInfoThe MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true をバインドできないときに例外をスローする場合は method、それ以外の場合は falsetrue to throw an exception if method cannot be bound; otherwise, false.

戻り値

指定された静的メソッドまたはインスタンス メソッドを表す、指定された型のデリゲート。nullthrowOnBindFailure で、デリゲートを false にバインドできない場合は methodA 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.

例外

typenull です。type is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- method はバインドできず、throwOnBindFailuretrue です。method cannot be bound, and throwOnBindFailure is true.

または-or- methodRuntimeMethodInfo ではありません。method is not a RuntimeMethodInfo. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

Invoketype メソッドが見つかりません。The Invoke method of type is not found.

method へのアクセスに必要なアクセス許可が呼び出し元にありません。The caller does not have the permissions necessary to access method.

ここでは、3つのコード例について説明します。This section contains three code examples. 最初の例では、作成可能な4種類のデリゲートを示しています。これは、インスタンスメソッドで終了し、インスタンスメソッドを開いて、静的メソッドを開いた後、静的メソッドで終了します。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.

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。The second code example demonstrates compatible parameter types and return types.

3番目のコード例では、単一のデリゲート型を定義し、デリゲート型が表すことができるすべてのメソッドを示します。The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

例 1Example 1

次のコード例は、CreateDelegate メソッドのこのオーバーロードを使用してデリゲートを作成する4つの方法を示しています。The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

注意

firstArgumentMethodInfoを指定する CreateDelegate メソッドには、2つのオーバーロードがあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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.

この例では、静的メソッド M2 とインスタンスメソッド M1、および3つのデリゲート型を使用して C クラスを宣言します。 D1 は、C のインスタンスと文字列を受け取り、D2 は引数を受け取りません。D3The 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 という名前の2番目のクラスには、デリゲートを作成するコードが含まれています。A second class named Example contains the code that creates the delegates.

  • Cのインスタンスで終了した D2型のデリゲートが、インスタンスメソッド 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.

このコード例では、Base という名前の基底クラスと、Baseから派生する Derived という名前のクラスを定義しています。The code example defines a base class named Base and a class named Derived that derives from Base. 派生クラスには、Base 型の1つのパラメーターと Derivedの戻り値の型を持つ MyMethod という名前の static (Shared Visual Basic) メソッドがあります。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. このコード例では、Derived 型の1つのパラメーターと Baseの戻り値の型を持つ Example という名前のデリゲートも定義します。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.

注意

firstArgumentMethodInfoを指定する CreateDelegate メソッドには、2つのオーバーロードがあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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の2つのクラスと、C型の引数を1つ持つ D デリゲート型を定義しています。The code example defines two classes, C and F, and a delegate type D with one argument of type C. クラスは、静的メソッドとインスタンスメソッド M1M3、および 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 という名前の3番目のクラスには、デリゲートを作成するコードが含まれています。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. C 型のメソッド M1 は、バインドされたインスタンスと引数の ID プロパティを表示します。Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • C型のメソッド M2 に対してデリゲートが作成されます。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.

  • デリゲートは、型 C 型および型 F; の静的メソッド M3 に対して作成されます。これらはオープンスタティックデリゲートです。Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • 最後に、C 型および型 F; の静的メソッド M4 に対してデリゲートが作成されます。各メソッドには、最初の引数として宣言する型があり、型のインスタンスが指定されているため、デリゲートは最初の引数に対して閉じられます。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. C 型のメソッド M4 は、バインドされたインスタンスと引数の 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) メソッドのオーバーロードは、バインドに失敗した場合は常にをスローします。これにより、デリゲートを作成するための最も柔軟な方法が提供されます。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 は非表示のインスタンスパラメーターに渡されます (のC#this によって表されるか、Visual Basic で Me)。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 (Visual Basic でShared) で、その最初のパラメーターの型が 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 は自動的にボックス化されます。In this case firstArgument is automatically boxed. C#または Visual Basic 関数呼び出しの場合と同様に、他の引数に対して自動ボックス化は行われません。Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

firstArgument が null 参照で、method がインスタンスメソッドの場合、結果は methodのデリゲート型 type およびのシグネチャに依存します。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.

  • methodtype のシグネチャが一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートは 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 が静的である場合、結果は methodのデリゲート型 type およびのシグネチャに依存します。If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • methodtype のシグネチャが一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートはオープンな静的メソッドを表すと言います。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 の2番目のパラメーターで始まり、その他のパラメーターの型に互換性がある場合、デリゲートは 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. デリゲートが呼び出されると、methodの最初のパラメーターに null 参照が渡されます。When the delegate is invoked, a null reference is passed to the first parameter of method.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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 のこのオーバーロードによって提供される柔軟性を考慮するもう1つの便利な方法として、特定のデリゲートは、メソッドシグネチャとメソッドの種類 (静的とインスタンス) の4種類の組み合わせを表すことができます。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). C型の引数を1つ持つ D デリゲート型を考えてみます。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:

  • D は、インスタンスメソッドが属する型に関係なく、C型の引数を1つだけ持つインスタンスメソッドを表すことができます。D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. CreateDelegate が呼び出されると、firstArgumentmethod が属している型のインスタンスになり、結果として得られるデリゲートはそのインスタンス上で閉じられると言います。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. (firstArgumentnullている場合は、null 参照を使用して D することもできます)。(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型の1つの引数を受け取る静的メソッドを表すことができ、そのメソッドは任意の型に属することができます。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の2つの引数を持つ静的メソッドを表すことができます。D can represent a static method that belongs to type F and has two arguments, of type F and type C. CreateDelegate が呼び出されると、firstArgumentFのインスタンスになります。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 が同じ型である場合、静的メソッドにはその型の2つの引数があります。Note that in the case where F and C are the same type, the static method has two arguments of that type. (この場合、firstArgumentnull場合、D は 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);
static member CreateDelegate : Type * obj * string * bool * bool -> Delegate

パラメーター

type
Type

作成するデリゲートの TypeThe 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

true をバインドできないときに例外をスローする場合は method、それ以外の場合は falsetrue to throw an exception if method cannot be bound; otherwise, false.

戻り値

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- method はインスタンス メソッドではありません。method is not an instance method.

または-or- 見つからないなどの原因により、method をバインドできません。また、throwOnBindFailuretrue です。method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Invoketype メソッドが見つかりません。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.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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);
static member CreateDelegate : Type * System.Reflection.MethodInfo * bool -> Delegate

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を保持する MethodInfoThe MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true をバインドできないときに例外をスローする場合は method、それ以外の場合は falsetrue to throw an exception if method cannot be bound; otherwise, false.

戻り値

指定した静的メソッドを表すための、指定した型のデリゲート。A delegate of the specified type to represent the specified static method.

例外

typenull です。type is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- method はバインドできず、throwOnBindFailuretrue です。method cannot be bound, and throwOnBindFailure is true.

または-or- methodRuntimeMethodInfo ではありません。method is not a RuntimeMethodInfo. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

Invoketype メソッドが見つかりません。The Invoke method of type is not found.

method へのアクセスに必要なアクセス許可が呼び出し元にありません。The caller does not have the permissions necessary to access method.

このセクションには、2 つのコード例が含まれています。This section contains two code examples. 最初の例は、このメソッドオーバーロードを使用して作成できる2種類のデリゲートを示しています。これは、インスタンスメソッドを開き、静的メソッドで開くことができます。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.

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。The second code example demonstrates compatible parameter types and return types.

例 1Example 1

次のコード例は、CreateDelegate メソッドのこのオーバーロードを使用してデリゲートを作成する2つの方法を示しています。The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

注意

最初の引数ではなく MethodInfo を指定する CreateDelegate メソッドのオーバーロードが2つあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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.

この例では、静的メソッド M2、インスタンスメソッド M1、および2つのデリゲート型を使用して C クラスを宣言します。 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 という名前の2番目のクラスには、デリゲートを作成するコードが含まれています。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.

このコード例では、Base という名前の基底クラスと、Baseから派生する Derived という名前のクラスを定義しています。The code example defines a base class named Base and a class named Derived that derives from Base. 派生クラスには、Base 型の1つのパラメーターと Derivedの戻り値の型を持つ MyMethod という名前の static (Shared Visual Basic) メソッドがあります。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. このコード例では、Derived 型の1つのパラメーターと Baseの戻り値の型を持つ Example という名前のデリゲートも定義します。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.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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

パラメーター

type
Type

作成するデリゲートの TypeThe 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.

戻り値

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。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.

Invoketype メソッドが見つかりません。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) メソッドのオーバーロードを呼び出し、throwOnBindFailureignoreCasetruefalse を指定した場合と同じです。This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

こちらもご覧ください

CreateDelegate(Type, Object, MethodInfo)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数を指定して作成します。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);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo -> Delegate

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

firstArgument
Object

デリゲートのバインド先のオブジェクト。nullmethod (Visual Basic の場合は static) として扱う場合は SharedThe object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を保持する MethodInfoThe MethodInfo describing the static or instance method the delegate is to represent.

戻り値

指定した静的メソッドまたはインスタンス メソッドを表すための、指定した型のデリゲート。A delegate of the specified type that represents the specified static or instance method.

例外

typenull です。type is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- method はバインドできません。method cannot be bound.

または-or- methodRuntimeMethodInfo ではありません。method is not a RuntimeMethodInfo. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

Invoketype メソッドが見つかりません。The Invoke method of type is not found.

method へのアクセスに必要なアクセス許可が呼び出し元にありません。The caller does not have the permissions necessary to access method.

ここでは、3つのコード例について説明します。This section contains three code examples. 最初の例では、作成可能な4種類のデリゲートを示しています。これは、インスタンスメソッドで終了し、インスタンスメソッドを開いて、静的メソッドを開いた後、静的メソッドで終了します。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.

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。The second code example demonstrates compatible parameter types and return types.

3番目のコード例では、単一のデリゲート型を定義し、デリゲート型が表すことができるすべてのメソッドを示します。The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

例 1Example 1

次のコード例は、CreateDelegate メソッドのこのオーバーロードを使用してデリゲートを作成する4つの方法を示しています。The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

注意

firstArgumentMethodInfoを指定する CreateDelegate メソッドには、2つのオーバーロードがあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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.

この例では、静的メソッド M2 とインスタンスメソッド M1、および3つのデリゲート型を使用して C クラスを宣言します。 D1 は、C のインスタンスと文字列を受け取り、D2 は引数を受け取りません。D3The 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 という名前の2番目のクラスには、デリゲートを作成するコードが含まれています。A second class named Example contains the code that creates the delegates.

  • Cのインスタンスで終了した D2型のデリゲートが、インスタンスメソッド 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.

このコード例では、Base という名前の基底クラスと、Baseから派生する Derived という名前のクラスを定義しています。The code example defines a base class named Base and a class named Derived that derives from Base. 派生クラスには、Base 型の1つのパラメーターと Derivedの戻り値の型を持つ MyMethod という名前の static (Shared Visual Basic) メソッドがあります。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. このコード例では、Derived 型の1つのパラメーターと Baseの戻り値の型を持つ Example という名前のデリゲートも定義します。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 メソッドを使用して、1つのデリゲート型が表すことができるすべてのメソッドを示しています。The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

注意

firstArgumentMethodInfoを指定する CreateDelegate メソッドには、2つのオーバーロードがあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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の2つのクラスと、C型の引数を1つ持つ D デリゲート型を定義しています。The code example defines two classes, C and F, and a delegate type D with one argument of type C. クラスは、静的メソッドとインスタンスメソッド M1M3、および 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 という名前の3番目のクラスには、デリゲートを作成するコードが含まれています。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. C 型のメソッド M1 は、バインドされたインスタンスと引数の ID プロパティを表示します。Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • C型のメソッド M2 に対してデリゲートが作成されます。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.

  • デリゲートは、型 C 型および型 F; の静的メソッド M3 に対して作成されます。これらはオープンスタティックデリゲートです。Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • 最後に、C 型および型 F; の静的メソッド M4 に対してデリゲートが作成されます。各メソッドには、最初の引数として宣言する型があり、型のインスタンスが指定されているため、デリゲートは最初の引数に対して閉じられます。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. C 型のメソッド M4 は、バインドされたインスタンスと引数の 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) メソッドのオーバーロードを呼び出し、throwOnBindFailuretrue を指定することと同じです。Calling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. これらの2つのオーバーロードは、最も柔軟なデリゲートを作成する方法を提供します。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 は非表示のインスタンスパラメーターに渡されます (のC#this によって表されるか、Visual Basic で Me)。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 (Visual Basic でShared) で、その最初のパラメーターの型が 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 は自動的にボックス化されます。In this case firstArgument is automatically boxed. C#または Visual Basic 関数呼び出しの場合と同様に、他の引数に対して自動ボックス化は行われません。Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

firstArgument が null 参照で、method がインスタンスメソッドの場合、結果は methodのデリゲート型 type およびのシグネチャに依存します。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.

  • methodtype のシグネチャが一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートは 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 が静的である場合、結果は methodのデリゲート型 type およびのシグネチャに依存します。If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • methodtype のシグネチャが一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートはオープンな静的メソッドを表すと言います。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 の2番目のパラメーターで始まり、その他のパラメーターの型に互換性がある場合、デリゲートは 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. デリゲートが呼び出されると、methodの最初のパラメーターに null 参照が渡されます。When the delegate is invoked, a null reference is passed to the first parameter of method.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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 のこのオーバーロードによって提供される柔軟性を考慮するもう1つの便利な方法として、特定のデリゲートは、メソッドシグネチャとメソッドの種類 (静的とインスタンス) の4種類の組み合わせを表すことができます。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). C型の引数を1つ持つ D デリゲート型を考えてみます。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:

  • D は、インスタンスメソッドが属する型に関係なく、C型の引数を1つだけ持つインスタンスメソッドを表すことができます。D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. CreateDelegate が呼び出されると、firstArgumentmethod が属している型のインスタンスになり、結果として得られるデリゲートはそのインスタンス上で閉じられると言います。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. (firstArgument が null 参照である場合は、D を null 参照に対しても閉じることができます)。(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型の1つの引数を受け取る静的メソッドを表すことができ、そのメソッドは任意の型に属することができます。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の2つの引数を持つ静的メソッドを表すことができます。D can represent a static method that belongs to type F and has two arguments, of type F and type C. CreateDelegate が呼び出されると、firstArgumentFのインスタンスになります。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 が同じ型である場合、静的メソッドにはその型の2つの引数があります。Note that in the case where F and C are the same type, the static method has two arguments of that type. (この場合、firstArgument が null 参照である場合、D は 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

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

target
Type

Type を実装するクラスを表す methodThe Type representing the class that implements method.

method
String

デリゲートによって表される静的メソッドの名前。The name of the static method that the delegate is to represent.

戻り値

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。A delegate of the specified type that represents the specified static method of the specified class.

例外

typenull です。type is null.

または-or- targetnull です。target is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

または-or- targetRuntimeType ではありません。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 をバインドできません。また、throwOnBindFailuretrue です。method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Invoketype メソッドが見つかりません。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) メソッドのオーバーロードを呼び出し、throwOnBindFailureignoreCasetruefalse を指定した場合と同じです。This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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

パラメーター

type
Type

作成するデリゲートの TypeThe Type of delegate to create.

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を保持する MethodInfoThe MethodInfo describing the static or instance method the delegate is to represent. .NET Framework Version 1.0 および 1.1 では、静的メソッドのみサポートされます。Only static methods are supported in the .NET Framework version 1.0 and 1.1.

戻り値

指定した静的メソッドを表すための、指定した型のデリゲート。A delegate of the specified type to represent the specified static method.

例外

typenull です。type is null.

または-or- methodnull です。method is null.

typeMulticastDelegate を継承しません。type does not inherit MulticastDelegate.

または-or- typeRuntimeType ではありません。type is not a RuntimeType. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。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- methodRuntimeMethodInfo ではありません。method is not a RuntimeMethodInfo. Runtime Types in Reflection」 (リフレクションのランタイム型) を参照してください。See Runtime Types in Reflection.

Invoketype メソッドが見つかりません。The Invoke method of type is not found.

method へのアクセスに必要なアクセス許可が呼び出し元にありません。The caller does not have the permissions necessary to access method.

このセクションには、2 つのコード例が含まれています。This section contains two code examples. 最初の例は、このメソッドオーバーロードを使用して作成できる2種類のデリゲートを示しています。これは、インスタンスメソッドを開き、静的メソッドで開くことができます。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.

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。The second code example demonstrates compatible parameter types and return types.

例 1Example 1

次のコード例は、CreateDelegate メソッドのこのオーバーロードを使用してデリゲートを作成する2つの方法を示しています。The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

注意

最初の引数ではなく MethodInfo を指定する CreateDelegate メソッドのオーバーロードが2つあります。これらの機能は同じですが、バインドに失敗した場合にをスローするかどうかを指定でき、もう1つは常にをスローします。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.

この例では、静的メソッド M2、インスタンスメソッド M1、および2つのデリゲート型を使用して C クラスを宣言します。 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 という名前の2番目のクラスには、デリゲートを作成するコードが含まれています。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.

このコード例では、Base という名前の基底クラスと、Baseから派生する Derived という名前のクラスを定義しています。The code example defines a base class named Base and a class named Derived that derives from Base. 派生クラスには、Base 型の1つのパラメーターと Derivedの戻り値の型を持つ MyMethod という名前の static (Shared Visual Basic) メソッドがあります。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. このコード例では、Derived 型の1つのパラメーターと Baseの戻り値の型を持つ Example という名前のデリゲートも定義します。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) メソッドのオーバーロードを呼び出し、throwOnBindFailuretrue を指定することと同じです。This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

注意

.NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1以降では、このメソッドを使用して、呼び出し元に ReflectionPermissionFlag.RestrictedMemberAccess フラグで ReflectionPermission が許可されていて、非パブリックメソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。Starting with the .NET Framework 2.0 Service Pack 1.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.NET Framework 3.5 以降を対象とする必要があります。To use this functionality, your application should target the .NET Framework 3.5.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.

こちらもご覧ください

適用対象