Delegate.CreateDelegate メソッド

定義

指定した型のデリゲートを作成します。

オーバーロード

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

大文字と小文字の区別方法およびバインドに失敗したときの動作を指定して、指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを作成します。

CreateDelegate(Type, Type, String, Boolean)

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを、大文字と小文字の区別方法を指定して作成します。

CreateDelegate(Type, Object, String, Boolean)

大文字と小文字の区別方法を指定して、指定したクラス インスタンスに対して呼び出す指定した型のデリゲートを作成します。

CreateDelegate(Type, Object, MethodInfo, Boolean)

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

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

大文字と小文字の区別方法およびバインドに失敗したときの動作を指定して、指定したクラス インスタンスに対して呼び出す指定した型のデリゲートを作成します。

CreateDelegate(Type, MethodInfo, Boolean)

指定された静的メソッドを表す、指定された型のデリゲートを、バインドに失敗した場合の動作を指定して作成します。

CreateDelegate(Type, Object, String)

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲートを作成します。

CreateDelegate(Type, Object, MethodInfo)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数を指定して作成します。

CreateDelegate(Type, Type, String)

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを作成します。

CreateDelegate(Type, MethodInfo)

指定した静的メソッドを表すために、指定した型のデリゲートを作成します。

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

大文字と小文字の区別方法およびバインドに失敗したときの動作を指定して、指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Type

method を実装するクラスを表す Type

method
String

デリゲートによって表される静的メソッドの名前。

ignoreCase
Boolean

メソッドの名前を比較するとき大文字と小文字を無視するかどうかを示すブール値。

throwOnBindFailure
Boolean

method をバインドできないときに例外をスローする場合は true。それ以外の場合は false

戻り値

Delegate

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - targetRuntimeType ではありません。

  • または - target はオープン ジェネリック型です。 つまり、その ContainsGenericParameters プロパティは true です。

  • または - methodstatic メソッド (Visual Basic では Shared メソッド) ではありません。

  • または - 見つからないなどの原因により、method をバインドできません。また、throwOnBindFailuretrue です。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、静的メソッドのデリゲートのみを作成します。 インスタンス メソッドは、 クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

注意

.NET Framework 2.0 Service Pack 1 より、呼び出し元に フラグが付与されている場合、および非パブリック メソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合は、このメソッドを使用して非パブリック メソッドにアクセスできます。 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションが 3.5 以降.NET Frameworkターゲットとする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, Type, String, Boolean)

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを、大文字と小文字の区別方法を指定して作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Type

method を実装するクラスを表す Type

method
String

デリゲートによって表される静的メソッドの名前。

ignoreCase
Boolean

メソッドの名前を比較するとき大文字と小文字を無視するかどうかを示すブール値。

戻り値

Delegate

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - targetRuntimeType ではありません。

  • または - target はオープン ジェネリック型です。 つまり、その ContainsGenericParameters プロパティは true です。

  • または - methodstatic メソッド (Visual Basic では Shared メソッド) ではありません。

  • または - method をバインドできません (たとえば、これが見つからないなど)。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、静的メソッドに対してのみデリゲートを作成します。 インスタンスメソッドは、クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

このメソッドオーバーロードは、にを指定してメソッドオーバーロードを呼び出すことと同じです CreateDelegate(Type, Type, String, Boolean, Boolean) true throwOnBindFailure

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, Object, String, Boolean)

大文字と小文字の区別方法を指定して、指定したクラス インスタンスに対して呼び出す指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Object

method を呼び出す対象のクラス インスタンス。

method
String

デリゲートによって表されるインスタンス メソッドの名前。

ignoreCase
Boolean

メソッドの名前を比較するとき大文字と小文字を無視するかどうかを示すブール値。

戻り値

Delegate

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - method はインスタンス メソッドではありません。

  • または - method をバインドできません (たとえば、これが見つからないなど)。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、インスタンスメソッドに対してのみデリゲートを作成します。 インスタンスメソッドは、クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

このメソッドオーバーロードは、にを指定してメソッドオーバーロードを呼び出すことと同じです CreateDelegate(Type, Object, String, Boolean, Boolean) true throwOnBindFailure

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, Object, MethodInfo, Boolean)

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

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

パラメーター

type
Type

作成するデリゲートの型を表す Type

firstArgument
Object

デリゲートが表すメソッドの第 1 引数である Object。 インスタンス メソッドの場合は、そのインスタンスの型との互換性が必要です。

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を記述する MethodInfo

throwOnBindFailure
Boolean

method をバインドできないときに例外をスローする場合は true。それ以外の場合は false

戻り値

Delegate

指定された静的メソッドまたはインスタンス メソッドを表す、指定された型のデリゲート。throwOnBindFailurefalse で、デリゲートを method にバインドできない場合は null

例外

typenullです。

または methodnullです。

typeMulticastDelegate を継承しません。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

ここでは、3つのコード例について説明します。 最初の例では、作成可能な4種類のデリゲートを示しています。これは、インスタンスメソッドで終了し、インスタンスメソッドを開いて、静的メソッドを開いた後、静的メソッドで終了します。

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。

3番目のコード例では、単一のデリゲート型を定義し、デリゲート型が表すことができるすべてのメソッドを示します。

例 1

次のコード例は、メソッドのこのオーバーロードを使用してデリゲートを作成する4つの方法を示して CreateDelegate います。

注意

とを指定するメソッドには2つのオーバーロードがあり CreateDelegate firstArgument MethodInfo ます。一方、バインドに失敗した場合にをスローするかどうかを指定でき、もう一方は常にをスローする点が異なります。 このコード例では、両方のオーバーロードを使用します。

この例では、 C 静的メソッドとインスタンスメソッドを持つクラスを宣言し、 M2 M1 3 つのデリゲート型を使用します。は D1 、のインスタンス C と文字列を受け取り、は引数を D2 取り D3 ません。

という名前の2つ目のクラスには Example 、デリゲートを作成するコードが含まれています。

  • のインスタンスで閉じられた型のデリゲート D2 C が、インスタンスメソッドに対して作成され M1 ます。 このメソッドは、のバインドされたインスタンス C が常に使用されることを示すために、異なる文字列を使用して呼び出されます。

  • D1オープンインスタンスメソッドを表す型のデリゲートが、インスタンスメソッドに対して作成され M1 ます。 デリゲートが呼び出されたときに、インスタンスを渡す必要があります。

  • D2静的メソッドに対して、オープンな静的メソッドを表す型のデリゲートが作成され M2 ます。

  • 最後に、文字列に対して閉じられた型のデリゲート D3 が、静的メソッドに対して作成され 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!
'

例 2

次のコード例は、パラメーターの型と戻り値の型の互換性を示しています。

注意

このコード例では、 CreateDelegate(Type, MethodInfo) メソッドオーバーロードを使用します。 が受け取る他のオーバーロードの使用方法 MethodInfo は似ています。

このコード例では、という名前の基底クラス Base と、から派生するという名前のクラスを定義して Derived Base います。 派生クラスには、 staticShared いう名前 MyMethod のパラメーターが1つあり、型が Base の戻り値の型を持つ (Visual Basic) メソッドがあり Derived ます。 また、このコード例では、 Example 型の1つのパラメーター Derived との戻り値の型を持つ、という名前のデリゲートも定義し Base ます。

このコード例は、という名前のデリゲートを使用してメソッドを表すことができることを示して Example MyMethod います。 メソッドは、次の理由によりデリゲートにバインドできます。

  • デリゲート () のパラメーターの型 Derived は、() のパラメーターの型よりも制限が厳しい MyMethod Base ため、デリゲートの引数をに常に渡すことが安全です MyMethod

  • () の戻り値の型 MyMethod Derived は、デリゲートのパラメーターの型 () よりも制限が厳しい Base ため、メソッドの戻り値の型をデリゲートの戻り値の型に常にキャストできます。

このコード例では、出力は生成されません。

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

例 3

次のコード例は、単一のデリゲート型が表すことができるすべてのメソッドを示しています。

注意

とを指定するメソッドには2つのオーバーロードがあり CreateDelegate firstArgument MethodInfo ます。一方、バインドに失敗した場合にをスローするかどうかを指定でき、もう一方は常にをスローする点が異なります。 このコード例では、両方のオーバーロードを使用します。

このコード例では、とという2つ C F のクラスと、 D 型の引数を1つ持つデリゲート型を定義して C います。 クラスには、静的メソッドとインスタンスメソッド、、およびが一致してい M1 M3 ます。また、クラスには、引数を M4 C 持たないインスタンスメソッドもあり M2 ます。

という名前の3番目のクラスには、 Example デリゲートを作成するコードが含まれています。

  • デリゲートは、型および型のインスタンスメソッドに対して作成され、 M1 C F それぞれの型のインスタンスに対して閉じられます。 型のメソッドは、 M1 C バインドされた ID インスタンスのプロパティと引数を表示します。

  • デリゲートは、型のメソッドに対して作成され M2 C ます。 これはオープンインスタンスデリゲートであり、デリゲートの引数はインスタンスメソッドの非表示の最初の引数を表します。 メソッドに他の引数はありません。

  • デリゲートは、型および型の静的メソッドに対して作成されます。 M3 C F これらはオープンスタティックデリゲートです。

  • 最後に、型および型の静的メソッドに対してデリゲートが作成され M4 C F ます。各メソッドには、最初の引数として宣言する型があり、型のインスタンスが指定されているため、デリゲートは最初の引数に対して閉じられます。 型のメソッドは、 M4 C バインドされた ID インスタンスのプロパティと引数を表示します。

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) メソッドのオーバーロードは、バインドに失敗した場合は常にをスローし、デリゲートを作成するための最も柔軟な方法を提供します。 これらのメソッドを使用すると、最初の引数の有無にかかわらず、静的メソッドまたはインスタンスメソッドのデリゲートを作成できます。

注意

最初の引数を指定しない場合は、メソッドオーバーロードを使用し CreateDelegate(Type, MethodInfo, Boolean) てパフォーマンスを向上させます。

デリゲート型とメソッドは、互換性のある戻り値の型を持っている必要があります。 つまり、の戻り値の型は、 method の戻り値の型に割り当て可能である必要があり type ます。

firstArgumentが指定されている場合、デリゲートが呼び出されるたびにに渡され method ます。 firstArgument はデリゲートにバインドされ、デリゲートは最初の引数に対して閉じられると言います。 methodstatic (Visual Basic) の場合 Shared 、デリゲートを呼び出すときに指定された引数リストには、最初のパラメーターを除くすべてのパラメーターが含まれます。 method がインスタンスメソッドの場合は、 firstArgument 非表示のインスタンスパラメーター (C# のでは、または Visual Basic) にが渡され this Me ます。

firstArgument 指定する場合、の最初のパラメーターは method 参照型である必要があり、 firstArgument その型と互換性がある必要があります。

重要

methodstatic ( Shared Visual Basic) で、その最初のパラメーターの型が Object またはである場合は、を ValueType firstArgument 値型にすることができます。 この場合、 firstArgument は自動的にボックス化されます。 C# または Visual Basic 関数呼び出しの場合と同様に、他の引数に対して自動ボックス化は行われません。

firstArgumentが null 参照で、 method がインスタンスメソッドである場合、結果はデリゲート型およびのシグネチャによって異なり type method ます。

  • のシグネチャに、 type の非表示の最初のパラメーターが明示的に含まれている場合 method 、デリゲートはオープンインスタンスメソッドを表していると言います。 デリゲートが呼び出されると、引数リストの最初の引数がの非表示インスタンスパラメーターに渡され method ます。

  • とのシグネチャが method type 一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートは null 参照に対して閉じられると言われます。 デリゲートの呼び出しは、null インスタンスでのインスタンスメソッドの呼び出しと似ていますが、これは特に便利な操作ではありません。

firstArgumentが null 参照で、 method が静的である場合、結果はデリゲート型およびのシグネチャによって異なり type method ます。

  • との署名が method type 一致する場合 (つまり、すべてのパラメーターの型に互換性がある場合)、デリゲートはオープンな静的メソッドを表すと言います。 これは、静的メソッドの最も一般的な例です。 この場合、メソッドオーバーロードを使用すると、パフォーマンスが若干向上し CreateDelegate(Type, MethodInfo, Boolean) ます。

  • のシグネチャが type の2番目のパラメーターで始まり、その他のパラメーターの型に互換性がある場合、 method デリゲートは null 参照で閉じられていると言います。 デリゲートが呼び出されると、の最初のパラメーターに null 参照が渡され method ます。

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

互換性のあるパラメーターの型と戻り値の型

デリゲートのパラメーターの型と戻り値の型は、デリゲートが表すメソッドのパラメーターの型および戻り値の型と互換性がある必要があります。型が正確に一致する必要はありません。

注意

.NET Framework バージョン1.0 および1.1 では、型は正確に一致している必要があります。

デリゲートのパラメーターにメソッドのパラメーターよりも限定的な型が指定された場合、両者のパラメーター間に型の互換性があると見なされます。これによって、デリゲートに渡された引数が、メソッドに対して安全に渡されることが保証されます。

同様に、メソッドの戻り値の型の制限がデリゲートの戻り値の型より多いと、メソッドの戻り値がデリゲートの戻り値の型に安全にキャストされることが保証されるため、デリゲートの戻り値の型とメソッドの戻り値の型には互換性があります。

たとえば、型のパラメーター Hashtable との戻り値の型を持つデリゲートは、 Object 型のパラメーターと Object 型の戻り値を持つメソッドを表すことができ Hashtable ます。

デリゲートが表すことができるメソッドの決定

このオーバーロードによって提供される柔軟性を考慮するもう1つの便利な方法として、特定のデリゲートは、 CreateDelegate メソッドシグネチャとメソッドの種類 (静的とインスタンス) の4種類の組み合わせを表すことができます。 D型の引数を1つ持つデリゲート型を考えてみ C ます。 次の例では、 D すべての場合に一致する必要があるため、戻り値の型を無視して、メソッドを表すことができます。

  • DC 、インスタンスメソッドが属する型に関係なく、型の引数を1つだけ持つ任意のインスタンスメソッドを表すことができます。 CreateDelegateが呼び出されると、 firstArgument は型のインスタンスが method に属し、結果として得られるデリゲートはそのインスタンスで閉じられると言います。 (がの D 場合は、null 参照でも閉じることができ firstArgument null ます)。

  • D は、引数を持たないのインスタンスメソッドを表すことができ C ます。 CreateDelegateが呼び出されると、 firstArgument は null 参照になります。 生成されるデリゲートは、オープンインスタンスメソッドを表します。のインスタンスは、呼び出されるたびに C 指定する必要があります。

  • D は、型の1つの引数を受け取る静的メソッドを表すことができ、 C そのメソッドは任意の型に属することができます。 CreateDelegateが呼び出されると、 firstArgument は null 参照になります。 結果として得られるデリゲートは、オープンな静的メソッドを表します。のインスタンスは、呼び出されるたびに C 指定する必要があります。

  • D 型に属し、型 F と型の2つの引数を持つ静的メソッドを表すことができ F C ます。 CreateDelegateが呼び出されると、 firstArgument はのインスタンスに F なります。 結果として得られるデリゲートは、のそのインスタンスで閉じられる静的メソッドを表し F ます。 Fとが同じ型である場合、 C 静的メソッドにはその型の2つの引数があります。 (この場合、 D がの場合、は null 参照で閉じられ firstArgument null ます)。

こちらもご覧ください

適用対象

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

大文字と小文字の区別方法およびバインドに失敗したときの動作を指定して、指定したクラス インスタンスに対して呼び出す指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Object

method を呼び出す対象のクラス インスタンス。

method
String

デリゲートによって表されるインスタンス メソッドの名前。

ignoreCase
Boolean

メソッドの名前を比較するとき大文字と小文字を無視するかどうかを示すブール値。

throwOnBindFailure
Boolean

method をバインドできないときに例外をスローする場合は true。それ以外の場合は false

戻り値

Delegate

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - method はインスタンス メソッドではありません。

  • または - 見つからないなどの原因により、method をバインドできません。また、throwOnBindFailuretrue です。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、インスタンスメソッドに対してのみデリゲートを作成します。 インスタンスメソッドは、クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションが 3.5 以降.NET Frameworkターゲットとする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, MethodInfo, Boolean)

指定された静的メソッドを表す、指定された型のデリゲートを、バインドに失敗した場合の動作を指定して作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を記述する MethodInfo

throwOnBindFailure
Boolean

method をバインドできないときに例外をスローする場合は true。それ以外の場合は false

戻り値

Delegate

指定した静的メソッドを表すための、指定した型のデリゲート。

例外

typenullです。

または methodnullです。

typeMulticastDelegate を継承しません。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

このセクションには、2 つのコード例が含まれています。 最初の例は、このメソッドオーバーロードを使用して作成できる2種類のデリゲートを示しています。これは、インスタンスメソッドを開き、静的メソッドで開くことができます。

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。

例 1

次のコード例は、メソッドのこのオーバーロードを使用してデリゲートを作成する2つの方法を示して CreateDelegate います。

注意

メソッドには2つのオーバーロードがあり CreateDelegate ますが、最初の引数は指定し MethodInfo ません。ただし、これらの機能は、バインドに失敗した場合にをスローするかどうかを指定でき、もう一方は常にをスローする点が異なります。 このコード例では、両方のオーバーロードを使用します。

この例では、 C 静的メソッドとインスタンスメソッドを持つクラスを宣言し、 M2 M1 2 つのデリゲート型を使用して、 D1 のインスタンス C と文字列を取得し、文字列を D2 取得します。

という名前の2つ目のクラスには Example 、デリゲートを作成するコードが含まれています。

  • D1オープンインスタンスメソッドを表す型のデリゲートが、インスタンスメソッドに対して作成され M1 ます。 デリゲートが呼び出されたときに、インスタンスを渡す必要があります。

  • D2静的メソッドに対して、オープンな静的メソッドを表す型のデリゲートが作成され 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!
'

例 2

次のコード例は、パラメーターの型と戻り値の型の互換性を示しています。

注意

このコード例では、 CreateDelegate(Type, MethodInfo) メソッドオーバーロードを使用します。 が受け取る他のオーバーロードの使用方法 MethodInfo は似ています。

このコード例では、という名前の基底クラス Base と、から派生するという名前のクラスを定義して Derived Base います。 派生クラスには、 staticShared いう名前 MyMethod のパラメーターが1つあり、型が Base の戻り値の型を持つ (Visual Basic) メソッドがあり Derived ます。 また、このコード例では、 Example 型の1つのパラメーター Derived との戻り値の型を持つ、という名前のデリゲートも定義し Base ます。

このコード例は、という名前のデリゲートを使用してメソッドを表すことができることを示して Example MyMethod います。 メソッドは、次の理由によりデリゲートにバインドできます。

  • デリゲート () のパラメーターの型 Derived は、() のパラメーターの型よりも制限が厳しい MyMethod Base ため、デリゲートの引数をに常に渡すことが安全です MyMethod

  • () の戻り値の型 MyMethod Derived は、デリゲートのパラメーターの型 () よりも制限が厳しい Base ため、メソッドの戻り値の型をデリゲートの戻り値の型に常にキャストできます。

このコード例では、出力は生成されません。

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

注釈

このメソッドオーバーロードは、開いている静的メソッドデリゲートを作成し、インスタンスメソッドデリゲートを開くことができます。つまり、インスタンスメソッドの非表示の最初の引数を公開するデリゲートです。 詳細については、「メソッドの一般的なオーバーロード」を参照してください CreateDelegate(Type, Object, MethodInfo, Boolean) 。これにより、インスタンスまたは静的メソッドに対して、オープンまたはクローズのデリゲートのすべての組み合わせを作成できます。

注意

このメソッドオーバーロードは、デリゲートが最初の引数に対して閉じられていない場合に使用する必要があります。これは、その場合は多少高速になるためです。

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

互換性のあるパラメーターの型と戻り値の型

デリゲートのパラメーターの型と戻り値の型は、デリゲートが表すメソッドのパラメーターの型および戻り値の型と互換性がある必要があります。型が正確に一致する必要はありません。

注意

.NET Framework バージョン1.0 および1.1 では、型は正確に一致する必要があります。

デリゲートのパラメーターにメソッドのパラメーターよりも限定的な型が指定された場合、両者のパラメーター間に型の互換性があると見なされます。これによって、デリゲートに渡された引数が、メソッドに対して安全に渡されることが保証されます。

同様に、メソッドの戻り値の型の制限がデリゲートの戻り値の型より多いと、メソッドの戻り値がデリゲートの戻り値の型に安全にキャストされることが保証されるため、デリゲートの戻り値の型とメソッドの戻り値の型には互換性があります。

たとえば、型のパラメーター Hashtable との戻り値の型を持つデリゲートは、 Object 型のパラメーターと Object 型の戻り値を持つメソッドを表すことができ Hashtable ます。

こちらもご覧ください

適用対象

CreateDelegate(Type, Object, String)

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Object

method を呼び出す対象のクラス インスタンス。

method
String

デリゲートによって表されるインスタンス メソッドの名前。

戻り値

Delegate

指定したクラス インスタンスに対して呼び出す指定したインスタンス メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - method はインスタンス メソッドではありません。

  • または - method をバインドできません (たとえば、これが見つからないなど)。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、インスタンスメソッドに対してのみデリゲートを作成します。 インスタンスメソッドは、クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

このメソッドのオーバーロードは、に対しておよびにを指定して、メソッドのオーバーロードを呼び出すことと同じです CreateDelegate(Type, Object, String, Boolean, Boolean) false ignoreCase true throwOnBindFailure

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, Object, MethodInfo)

指定された静的メソッドまたはインスタンス メソッドを表す、指定した型のデリゲートを、第 1 引数を指定して作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

firstArgument
Object

デリゲートのバインド先のオブジェクト。methodstatic (Visual Basic の場合は Shared) として扱う場合は null

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を記述する MethodInfo

戻り値

Delegate

指定した静的メソッドまたはインスタンス メソッドを表すための、指定した型のデリゲート。

例外

typenullです。

または methodnullです。

typeMulticastDelegate を継承しません。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

このセクションには、3 つのコード例が含まれている。 最初の例は、作成できる 4 種類のデリゲートを示しています。インスタンス メソッドで閉じ、インスタンス メソッドで開く、静的メソッドで開く、静的メソッドで閉じます。

2 番目のコード例では、互換性のあるパラメーター型と戻り値の型を示します。

3 番目のコード例では、1 つのデリゲート型を定義し、デリゲート型が表すすべてのメソッドを示します。

例 1

次のコード例は、 メソッドのこのオーバーロードを使用してデリゲートを作成する 4 つの方法を示 CreateDelegate しています。

注意

と を指定するメソッドには 2 つのオーバーロードがあります。その機能は同じですが、1 つはバインドに失敗した場合に スローするかどうかを指定できる点と、他のオーバーロードは常にスローする点が異なっています。 CreateDelegate firstArgument MethodInfo このコード例では、両方のオーバーロードを使用します。

この例では、静的メソッドとインスタンス メソッド を使用してクラスを宣言し、 のインスタンスと文字列を受け取り、文字列を受け取り、引数を持たない 3 つのデリゲート型を宣言します C M2 M1 D1 C D2 D3

という名前の Example 2 番目のクラスには、デリゲートを作成するコードが含まれている。

  • のインスタンスで閉じた 型のデリゲートが、 D2 C インスタンス メソッド に対して作成されます M1 。 バインドされた インスタンスが常に使用されるのを示す、異なる文字列で C 呼び出されます。

  • オープン インスタンス メソッドを表す 型のデリゲートが、インスタンス D1 メソッド に対して作成されます M1 。 デリゲートが呼び出されると、インスタンスを渡す必要があります。

  • オープン静的メソッドを D2 表す 型のデリゲートが、静的メソッド に対して作成されます M2

  • 最後に、静的メソッド に対して、文字列で閉じた 型のデリゲート D3 が作成されます 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!
'

例 2

次のコード例は、パラメーター型と戻り値の型の互換性を示しています。

注意

このコード例では、 メソッドオーバーロード CreateDelegate(Type, MethodInfo) を使用します。 を受け取る他のオーバーロードの使用 MethodInfo も同様です。

このコード例では、 という名前の基本クラスと、 から派生 Base する という名前 Derived のクラスを定義します Base 。 派生クラスには、 型のパラメーターが 1 つ、戻り値の型が Visual Basic) という名前の メソッド static Shared MyMethod Base があります Derived 。 また、このコード例では、 型の 1 つのパラメーターと戻り値の型を持つ という名前 Example Derived のデリゲートも定義します Base

このコード例は、 という名前のデリゲートを使用して メソッド Example を表す方法を示しています MyMethod 。 メソッドは、次の理由でデリゲートにバインドできます。

  • デリゲートのパラメーター型 ( ) は、 のパラメーター型よりも制限が厳しいので、デリゲートの引数を に渡しても常 Derived MyMethod Base に安全です MyMethod

  • ( ) の戻り値の型は、デリゲートのパラメーター型 ( ) よりも制限が厳しいので、メソッドの戻り値の型をデリゲートの戻り値の型にキャストしても常に安全です MyMethod Derived Base

このコード例では、出力は生成されません。

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

例 3

次のコード例は、 メソッドを使用してデリゲートを作成し、1 つのデリゲート型が表すすべての CreateDelegate メソッドを示しています。

注意

と を指定するメソッドには 2 つのオーバーロードがあります。その機能は同じですが、1 つはバインドに失敗した場合に スローするかどうかを指定できる点と、他のオーバーロードは常にスローする点が異なっています。 CreateDelegate firstArgument MethodInfo このコード例では、両方のオーバーロードを使用します。

このコード例では、 と の 2 つのクラスと、 型の引数が 1 つの C F D デリゲート型を定義しています C 。 クラスには、、、および の静的メソッドとインスタンス メソッドが一致し、クラスには引数を持つインスタンス M1 M3 M4 C M2 メソッドも含まれています。

という名前の Example 3 番目のクラスには、デリゲートを作成するコードが含まれている。

  • デリゲートは、型と型のインスタンス メソッドに対して作成されます。各デリゲートは、それぞれの型の M1 C F インスタンスで閉じられます。 型 M1 のメソッドは C 、バインド ID されたインスタンスのプロパティと引数のプロパティを表示します。

  • デリゲートは、 型のメソッド M2 に対して作成されます C 。 これはオープン インスタンス デリゲートです。このデリゲートの引数は、インスタンス メソッドの非表示の最初の引数を表します。 メソッドには他の引数はありません。 静的メソッドである場合と同様に呼び出されます。

  • デリゲートは、型と型の静的 M3 メソッドに C 対して作成されます F 。これらはオープンな静的デリゲートです。

  • 最後に、型と型の静的メソッドに対してデリゲートが作成されます。各メソッドは宣言型を最初の引数として持ち、型のインスタンスが指定されます。そのため、デリゲートは最初の引数で閉じられます。 M4 C FM4 のメソッドは C 、バインド ID されたインスタンスのプロパティと引数のプロパティを表示します。

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

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

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

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

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

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

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

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

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

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

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

        D d;

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

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

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

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

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

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

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

/* This code example produces the following output:

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

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

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

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

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

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

    Private _id As Integer

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

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


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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

注釈

このメソッドのオーバーロードを呼び出すことは、メソッドのオーバーロードを呼び出し、にを指定することと同じです CreateDelegate(Type, Object, MethodInfo, Boolean) true throwOnBindFailure 。 これらの2つのオーバーロードは、最も柔軟なデリゲートを作成する方法を提供します。 これらのメソッドを使用して、静的メソッドまたはインスタンスメソッドのデリゲートを作成できます。また、必要に応じて、最初の引数を指定することもできます。

注意

最初の引数を指定しない場合は、メソッドオーバーロードを使用し CreateDelegate(Type, MethodInfo) てパフォーマンスを向上させます。

デリゲート型とメソッドは、互換性のある戻り値の型を持っている必要があります。 つまり、 の戻り値の型は method 、 の戻り値の型に割り当て可能である必要があります type

が指定されている場合は、デリゲートが呼び出されるたび に渡されます。デリゲートにバインドされると呼び出され、デリゲートは最初の引数で閉じられます firstArgument method firstArgument 。 が ( Visual Basic の場合) は、デリゲートの呼び出し時に指定された引数リストに、最初の パラメーターを除くすべてのパラメーターが含まれます。が インスタンス メソッドの場合は、非表示のインスタンス パラメーター method static Shared method firstArgument this (C# Me では で表されます、Visual Basic では によって表されます) に渡されます。

firstArgument 指定されている場合、 の最初のパラメーターは参照型である必要があり、その method firstArgument 型と互換性がある必要があります。

重要

が ( の場合Visual Basic) で、最初のパラメーターが または 型の場合は method static Shared Object ValueTypefirstArgument 値型を指定できます。 この場合は firstArgument 、自動的にボックスに設定されます。 自動ボックス化は、C# や関数呼び出しの場合と同様に、他Visual Basic発生しません。

が null 参照で、 がインスタンス メソッドの場合、結果は デリゲート型の シグネチャと のシグネチャ firstArgument method type によって異なります method

  • のシグネチャに の非表示の最初のパラメーターが明示的に含まれる場合、デリゲートはオープン インスタンス type method メソッドを表すと言います。 デリゲートが呼び出されると、引数リストの最初の引数が の非表示のインスタンス パラメーターに渡されます method

  • と のシグネチャが一致する場合 (つまり、すべてのパラメーター型に互換性があります)、デリゲートは null 参照で method type 閉じられます。 デリゲートの呼び出しは、null インスタンスでインスタンス メソッドを呼び出すのと似たものですが、これは特に役に立つ処理ではありません。

が null 参照であり、静的である場合、結果は デリゲート型の シグネチャと のシグネチャ firstArgument method によって type 異なります method

  • と のシグネチャが一致する (つまり、すべてのパラメーター型が互換性がある) 場合、デリゲートはオープン静的メソッド method type を表すと言います。 これは、静的メソッドの最も一般的なケースです。 この場合、 メソッドオーバーロードを使用すると、パフォーマンスが若干 CreateDelegate(Type, MethodInfo) 向上します。

  • のシグネチャが の 2 番目のパラメーターで始まり、残りのパラメーター型に互換性がある場合、デリゲートは null 参照で閉じられます type method 。 デリゲートが呼び出されると、 の最初のパラメーターに null 参照が渡されます method

注意

.NET Framework 2.0 Service Pack 1 より、呼び出し元に フラグが付与されている場合、および非パブリック メソッドの許可セットが呼び出し元の許可セットまたはそのサブセットに制限されている場合は、このメソッドを使用して非パブリック メソッドにアクセスできます。 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションが 3.5 以降.NET Frameworkターゲットとする必要があります。

互換性のあるパラメーター型と戻り値の型

デリゲートのパラメーター型と戻り値の型は、デリゲートが表すメソッドのパラメーター型および戻り値の型と互換性がある必要があります。型が完全に一致する必要はない。

注意

バージョン 1.0 .NET Framework 1.1 の場合、型は完全に一致する必要があります。

デリゲートのパラメーターにメソッドのパラメーターよりも限定的な型が指定された場合、両者のパラメーター間に型の互換性があると見なされます。これによって、デリゲートに渡された引数が、メソッドに対して安全に渡されることが保証されます。

同様に、メソッドの戻り値の型の制限がデリゲートの戻り値の型より多いと、メソッドの戻り値がデリゲートの戻り値の型に安全にキャストされることが保証されるため、デリゲートの戻り値の型とメソッドの戻り値の型には互換性があります。

たとえば、 型のパラメーターと の戻り値の型を持つデリゲートは、 型のパラメーターと 型の戻り値を持つメソッド Hashtable Object Object を表します Hashtable

デリゲートが表すメソッドの決定

のこのオーバーロードによって提供される柔軟性を考えるもう 1 つの便利な方法は、特定のデリゲートがメソッド シグネチャとメソッドの種類 (静的とインスタンス) の 4 つの異なる組み合わせを表す CreateDelegate 可能性がある点です。 型の 1 つの D 引数を持つデリゲート型について考えてみてください C 。 次に示すのは、すべてのケースで一致する必要がある戻り値の型を無視して、メソッドが表す可能性がある D メソッドです。

  • D は、インスタンス メソッドが属する型に関係なく、 型の引数が 1 つのインスタンス メソッド C を表す場合があります。 が呼び出された場合、 は型のインスタンスが属し、結果のデリゲートは、そのインスタンスで CreateDelegate firstArgument method 閉じられると言います。 (が null 参照の場合は、null 参照で D firstArgument 閉じられます)。

  • D は、引数がない の C インスタンス メソッドを表す場合があります。 が CreateDelegate 呼び出された場合 firstArgument 、 は null 参照です。 結果のデリゲートは開いているインスタンス メソッドを表し、 のインスタンスは呼び出すごとに指定 C する必要があります。

  • D は、 型の 1 つの引数を受け取る静的メソッドを表し、そのメソッド C は任意の型に属することができます。 が CreateDelegate 呼び出された場合 firstArgument 、 は null 参照です。 結果のデリゲートは、開いている静的メソッドを表し、 のインスタンスを呼び出す C ごとに指定する必要があります。

  • D 型に属し、 型と 型の 2 つの引数を持つ静的 F メソッドを F 表す場合があります C 。 が CreateDelegate 呼び出された場合 firstArgument 、 は のインスタンスです F 。 結果のデリゲートは、 のインスタンスで閉じられる静的メソッドを表します F 。 と が同じ型の場合、静的メソッドにはその型の F C 2 つの引数があります。 (この場合、 が D null 参照の場合、 は null 参照 firstArgument で閉じられます)。

こちらもご覧ください

適用対象

CreateDelegate(Type, Type, String)

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

target
Type

method を実装するクラスを表す Type

method
String

デリゲートによって表される静的メソッドの名前。

戻り値

Delegate

指定したクラスの指定した静的メソッドを表す、指定した型のデリゲート。

例外

typenullです。

または targetnull です。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - targetRuntimeType ではありません。

  • または - target はオープン ジェネリック型です。 つまり、その ContainsGenericParameters プロパティは true です。

  • または - methodstatic メソッド (Visual Basic では Shared メソッド) ではありません。

  • または - 見つからないなどの原因により、method をバインドできません。また、throwOnBindFailuretrue です。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

注釈

このメソッドは、静的メソッドに対してのみデリゲートを作成します。 インスタンスメソッドは、クラスのインスタンスに関連付けられているメソッドです。静的メソッドは、クラス自体に関連付けられているメソッドです。

このメソッドのオーバーロードは、に対しておよびにを指定して、メソッドのオーバーロードを呼び出すことと同じです CreateDelegate(Type, Type, String, Boolean, Boolean) false ignoreCase true throwOnBindFailure

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

こちらもご覧ください

適用対象

CreateDelegate(Type, MethodInfo)

指定した静的メソッドを表すために、指定した型のデリゲートを作成します。

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

パラメーター

type
Type

作成するデリゲートの Type

method
MethodInfo

デリゲートが表す静的メソッドまたはインスタンス メソッドの情報を記述する MethodInfo。 .NET Framework Version 1.0 および 1.1 では、静的メソッドのみサポートされます。

戻り値

Delegate

指定した静的メソッドを表すための、指定した型のデリゲート。

例外

typenullです。

または methodnullです。

typeMulticastDelegate を継承しません。

  • または - typeRuntimeType ではありません。 「リフレクションのランタイム型」を参照してください。

  • または - method は静的メソッドではなく、.NET Framework バージョンは 1.0 または 1.1 です。

  • または - method はバインドできません。

  • または - methodRuntimeMethodInfo ではありません。 「リフレクションのランタイム型」を参照してください。

typeInvoke メソッドが見つかりません。

method へのアクセスに必要なアクセス許可が呼び出し元にありません。

このセクションには、2 つのコード例が含まれています。 最初の例は、このメソッドオーバーロードを使用して作成できる2種類のデリゲートを示しています。これは、インスタンスメソッドを開き、静的メソッドで開くことができます。

2番目のコード例は、互換性のあるパラメーターの型と戻り値の型を示しています。

例 1

次のコード例は、メソッドのこのオーバーロードを使用してデリゲートを作成する2つの方法を示して CreateDelegate います。

注意

メソッドには2つのオーバーロードがあり CreateDelegate ますが、最初の引数は指定し MethodInfo ません。ただし、これらの機能は、バインドに失敗した場合にをスローするかどうかを指定でき、もう一方は常にをスローする点が異なります。 このコード例では、両方のオーバーロードを使用します。

この例では、 C 静的メソッドとインスタンスメソッドを持つクラスを宣言し、 M2 M1 2 つのデリゲート型を使用して、 D1 のインスタンス C と文字列を取得し、文字列を D2 取得します。

という名前の2つ目のクラスには Example 、デリゲートを作成するコードが含まれています。

  • D1オープンインスタンスメソッドを表す型のデリゲートが、インスタンスメソッドに対して作成され M1 ます。 デリゲートが呼び出されたときに、インスタンスを渡す必要があります。

  • D2静的メソッドに対して、オープンな静的メソッドを表す型のデリゲートが作成され 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!
'

例 2

次のコード例は、パラメーターの型と戻り値の型の互換性を示しています。

このコード例では、という名前の基底クラス Base と、から派生するという名前のクラスを定義して Derived Base います。 派生クラスには、 staticShared いう名前 MyMethod のパラメーターが1つあり、型が Base の戻り値の型を持つ (Visual Basic) メソッドがあり Derived ます。 また、このコード例では、 Example 型の1つのパラメーター Derived との戻り値の型を持つ、という名前のデリゲートも定義し Base ます。

このコード例は、という名前のデリゲートを使用してメソッドを表すことができることを示して Example MyMethod います。 メソッドは、次の理由によりデリゲートにバインドできます。

  • デリゲート () のパラメーターの型 Derived は、() のパラメーターの型よりも制限が厳しい MyMethod Base ため、デリゲートの引数をに常に渡すことが安全です MyMethod

  • () の戻り値の型 MyMethod Derived は、デリゲートのパラメーターの型 () よりも制限が厳しい Base ため、メソッドの戻り値の型をデリゲートの戻り値の型に常にキャストできます。

このコード例では、出力は生成されません。

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 では、このメソッドオーバーロードは静的メソッドに対してのみデリゲートを作成します。 .NET Framework バージョン2.0 では、このメソッドオーバーロードは、オープンインスタンスメソッドデリゲートを作成することもできます。つまり、インスタンスメソッドの非表示の最初の引数を明示的に指定するデリゲート。 詳細については、 CreateDelegate(Type, Object, MethodInfo) インスタンスまたは静的メソッドのオープンまたはクローズデリゲートのすべての組み合わせを作成できるようにする、より一般的なメソッドオーバーロードに関する説明を参照してください。また、必要に応じて、最初の引数を指定することもできます。

注意

このメソッドオーバーロードは、デリゲートが最初の引数に対して閉じられていない場合に使用する必要があります。これは、その場合は多少高速になるためです。

このメソッドのオーバーロードは、メソッドのオーバーロードを呼び出し、にを指定することと同じです CreateDelegate(Type, MethodInfo, Boolean) true throwOnBindFailure

注意

.NET Framework 2.0 Service Pack 1 以降では、このメソッドを使用して、呼び出し元がフラグで許可されている場合、 ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess パブリックでないメソッドの許可セットが呼び出し元の許可セットまたはサブセットに制限されている場合に、パブリックでないメソッドにアクセスできます。 (「 リフレクションのセキュリティに関する考慮事項」を参照してください)。

この機能を使用するには、アプリケーションで .NET Framework 3.5 以降を対象にする必要があります。

互換性のあるパラメーターの型と戻り値の型

.NET Framework バージョン2.0 では、このメソッドオーバーロードを使用して作成されたデリゲートのパラメーターの型と戻り値の型は、デリゲートが表すメソッドのパラメーターの型および戻り値の型と互換性がある必要があります。型が正確に一致する必要はありません。 これは .NET Framework バージョン1.0 および1.1 でのバインディング動作の緩和を表します。この場合、型は正確に一致する必要があります。

デリゲートのパラメーターにメソッドのパラメーターよりも限定的な型が指定された場合、両者のパラメーター間に型の互換性があると見なされます。これによって、デリゲートに渡された引数が、メソッドに対して安全に渡されることが保証されます。

同様に、メソッドの戻り値の型の制限がデリゲートの戻り値の型より多いと、メソッドの戻り値がデリゲートの戻り値の型に安全にキャストされることが保証されるため、デリゲートの戻り値の型とメソッドの戻り値の型には互換性があります。

たとえば、型のパラメーター Hashtable との戻り値の型を持つデリゲートは、 Object 型のパラメーターと Object 型の戻り値を持つメソッドを表すことができ Hashtable ます。

こちらもご覧ください

適用対象