Delegate.CreateDelegate Méthode

Définition

Crée un délégué du type spécifié.Creates a delegate of the specified type.

Surcharges

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

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, Type, String, Boolean)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

CreateDelegate(Type, Object, String, Boolean)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

CreateDelegate(Type, Object, MethodInfo, Boolean)

Crée un délégué du type spécifié qui représente la méthode statique ou d'instance spécifiée, avec le premier argument spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

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

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, MethodInfo, Boolean)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée, avec le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

CreateDelegate(Type, Object, String)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, MethodInfo)

Crée un délégué du type spécifié qui représente la méthode statique ou méthode d'instance spécifiée, avec le premier argument spécifié.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Type, String)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, MethodInfo)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée.Creates a delegate of the specified type to represent the specified static method.

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

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Type

Type représentant la classe qui implémente method.The Type representing the class that implements method.

method
String

Nom de la méthode statique que doit représenter le délégué.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Valeur booléenne indiquant si la casse doit être ignorée pendant la comparaison du nom de la méthode.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true pour lever une exception si method ne peut pas être lié ; sinon, false.true to throw an exception if method cannot be bound; otherwise, false.

Retours

Délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.A delegate of the specified type that represents the specified static method of the specified class.

Exceptions

type est null.type is null.

- ou --or- target a la valeur null.target is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

ou-or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

ou-or- target n'est pas un RuntimeType.target is not a RuntimeType.

ou-or- target est un type générique ouvert.target is an open generic type. Autrement dit, sa propriété ContainsGenericParameters a la valeur true.That is, its ContainsGenericParameters property is true.

- ou --or- method n’est pas une méthode static (méthode Shared en Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- method ne peut pas être lié, par exemple car elle est introuvable, et throwOnBindFailure a la valeur true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes statiques uniquement.This method creates delegates for static methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Type, String, Boolean)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Type

Type représentant la classe qui implémente method.The Type representing the class that implements method.

method
String

Nom de la méthode statique que doit représenter le délégué.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Valeur booléenne indiquant si la casse doit être ignorée pendant la comparaison du nom de la méthode.A Boolean indicating whether to ignore the case when comparing the name of the method.

Retours

Délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.A delegate of the specified type that represents the specified static method of the specified class.

Exceptions

type a la valeur null.type is null.

- ou --or- target est null.target is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

- ou --or- target n'est pas un RuntimeType.target is not a RuntimeType.

ou-or- target est un type générique ouvert.target is an open generic type. Autrement dit, sa propriété ContainsGenericParameters a la valeur true.That is, its ContainsGenericParameters property is true.

- ou --or- method n’est pas une méthode static (méthode Shared en Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- method ne peut pas être lié, ce qui peut arriver s’il est introuvable.method cannot be bound, for example because it cannot be found.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes statiques uniquement.This method creates delegates for static methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Cette surcharge de méthode équivaut à appeler la CreateDelegate(Type, Type, String, Boolean, Boolean) surcharge de méthode, true en throwOnBindFailurespécifiant pour.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Object, String, Boolean)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Object

Instance de classe sur laquelle la méthode method est appelée.The class instance on which method is invoked.

method
String

Nom de la méthode d’instance que doit représenter le délégué.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Valeur booléenne indiquant si la casse doit être ignorée pendant la comparaison du nom de la méthode.A Boolean indicating whether to ignore the case when comparing the name of the method.

Retours

Délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceptions

type a la valeur null.type is null.

- ou --or- target a la valeur null.target is null.

- ou --or- method est null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

- ou --or- method n’est pas une méthode d’instance.method is not an instance method.

ou-or- method ne peut pas être lié, ce qui peut arriver s’il est introuvable.method cannot be bound, for example because it cannot be found.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes d’instance uniquement.This method creates delegates for instance methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Cette surcharge de méthode équivaut à appeler la CreateDelegate(Type, Object, String, Boolean, Boolean) surcharge de méthode, true en throwOnBindFailurespécifiant pour.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Object, MethodInfo, Boolean)

Crée un délégué du type spécifié qui représente la méthode statique ou d'instance spécifiée, avec le premier argument spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

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

Paramètres

type
Type

Type représentant le type de délégué à créer.A Type representing the type of delegate to create.

firstArgument
Object

Object correspondant au premier argument de la méthode que le délégué représente.An Object that is the first argument of the method the delegate represents. Pour les méthodes d'instance, il doit être compatible avec le type d'instance.For instance methods, it must be compatible with the instance type.

method
MethodInfo

MethodInfo décrivant la méthode statique ou d’instance que le délégué doit représenter.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true pour lever une exception si method ne peut pas être lié ; sinon, false.true to throw an exception if method cannot be bound; otherwise, false.

Retours

Délégué du type spécifié qui représente la méthode statique ou d’instance spécifiée, ou null si throwOnBindFailure a la valeur false et que le délégué ne peut pas être lié à method.A delegate of the specified type that represents the specified static or instance method, or null if throwOnBindFailure is false and the delegate cannot be bound to method.

Exceptions

type a la valeur null.type is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

- ou --or- method ne peut pas être lié et throwOnBindFailure a la valeur true.method cannot be bound, and throwOnBindFailure is true.

- ou --or- method n’est pas un RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Exemples

Cette section contient trois exemples de code.This section contains three code examples. Le premier exemple montre les quatre genres de délégués qui peuvent être créés : fermés sur une méthode d’instance, ouverts sur une méthode d’instance, ouverts sur une méthode statique et fermés sur une méthode statique.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

Le deuxième exemple de code illustre les types de paramètres compatibles et les types de retour.The second code example demonstrates compatible parameter types and return types.

Le troisième exemple de code définit un type délégué unique et affiche toutes les méthodes que le type délégué peut représenter.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Exemple 1Example 1

L’exemple de code suivant montre les quatre façons dont un délégué peut être créé à l’aide CreateDelegate de cette surcharge de la méthode.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient firstArgument et MethodInfoa ; leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple déclare C une classe avec une méthode M2 statique et une méthode M1d’instance, et trois types délégués : D1 prend une instance de C et une chaîne, D2 prend une chaîne et D3n’a pas d’arguments.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

Une deuxième classe nommée Example contient le code qui crée les délégués.A second class named Example contains the code that creates the delegates.

  • Un délégué de type D2, fermé sur une instance de C, est créé pour la méthode M1d’instance.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Elle est appelée avec des chaînes différentes, pour indiquer que l’instance liée de C est toujours utilisée.It is invoked with different strings, to show that the bound instance of C is always used.

  • Un délégué de type D1, qui représente une méthode d’instance ouverte, est créé pour la M1méthode d’instance.A delegate of type D1, representing an open instance method, is created for the instance method M1. Une instance doit être passée lorsque le délégué est appelé.An instance must be passed when the delegate is invoked.

  • Un délégué de type D2, représentant une méthode statique ouverte, est créé pour la méthode M2statique.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Enfin, un délégué de type D3, fermé sur une chaîne, est créé pour la méthode M2statique.Finally, a delegate of type D3, closed over a string, is created for the static method M2. La méthode est appelée pour montrer qu’elle utilise la chaîne liée.The method is invoked to show that it uses the bound string.

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

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

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

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

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

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

        D1 d1;
        D2 d2;
        D3 d3;


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

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

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


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

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


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

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


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

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

/* This code example produces the following output:

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

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

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

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

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

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

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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

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

Exemple 2Example 2

L’exemple de code suivant illustre la compatibilité des types de paramètres et des types de retour.The following code example demonstrates compatibility of parameter types and return types.

Notes

Cet exemple de code utilise CreateDelegate(Type, MethodInfo) la surcharge de méthode.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L’utilisation d’autres surcharges qui prennent MethodInfo sont similaires.The use of other overloads that take MethodInfo is similar.

L’exemple de code définit une classe de Base base nommée et une Derived classe nommée qui dérive de Base.The code example defines a base class named Base and a class named Derived that derives from Base. La classe dérivée a static uneShared méthode (dans Visual Basic) MyMethod nommée avec un paramètre de Base type et un type de Derivedretour.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. L’exemple de code définit également un délégué Example nommé qui a un paramètre de Derived type et un type de Baseretour.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

L’exemple de code montre que le délégué Example nommé peut être utilisé pour représenter la MyMethodméthode.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. La méthode peut être liée au délégué, car :The method can be bound to the delegate because:

  • Le type de paramètre du délégué (Derived) est plus restrictif que le type de paramètre MyMethod deBase(), afin qu’il soit toujours sûr de passer l’argument du délégué à MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Le type de retour MyMethod deDerived() est plus restrictif que le type de paramètre du déléguéBase(), de sorte qu’il est toujours sûr d’effectuer un cast du type de retour de la méthode vers le type de retour du délégué.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

L’exemple de code ne produit pas de sortie.The code example produces no output.

using namespace System;
using namespace System::Reflection;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Derived
    Inherits Base

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

End Class

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

Module Test

    Sub Main()

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

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

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

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

Exemple 3Example 3

L’exemple de code suivant montre toutes les méthodes qu’un type délégué unique peut représenter.The following code example shows all the methods a single delegate type can represent.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient firstArgument et MethodInfoa ; leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple de code définit deux classes C , Fet, et un type D délégué avec un argument de Ctype.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Les classes ont M1des méthodes d’instance et statiques correspondantes, M3, C et M4, et la classe M2 a également une méthode d’instance qui n’a pas d’arguments.The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

Une troisième classe nommée Example contient le code qui crée les délégués.A third class named Example contains the code that creates the delegates.

  • Les délégués sont créés pour une M1 méthode d' C instance de Ftype et de type ; chacun est fermé sur une instance du type respectif.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Méthode M1 de type C affiche les ID propriétés de l’instance liée et de l’argument.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Un délégué est créé pour la M2 méthode de Ctype.A delegate is created for method M2 of type C. Il s’agit d’un délégué d’instance ouvert, dans lequel l’argument du délégué représente le premier argument masqué sur la méthode d’instance.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. La méthode n’a pas d’autres arguments.The method has no other arguments.

  • Les délégués sont créés pour une M3 méthode statique C de type Fet de type ; il s’agit de délégués statiques ouverts.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Enfin, les délégués sont créés pour une M4 méthode statique C de type Fet de type ; chaque méthode a le type déclarant comme premier argument et une instance du type est fournie, donc les délégués sont fermés sur leurs premiers arguments. .Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. Méthode M4 de type C affiche les ID propriétés de l’instance liée et de l’argument.Method M4 of type C displays the ID properties of the bound instance and of the argument.

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

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

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

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

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

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

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


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

        D d;

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

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

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

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

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

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

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

/* This code example produces the following output:

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

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

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

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

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

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

    Private _id As Integer

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

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


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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

Remarques

Cette surcharge de méthode et CreateDelegate(Type, Object, MethodInfo) la surcharge de méthode, qui lève toujours une exception en cas d’échec de liaison, fournissent la méthode la plus souple pour créer des délégués.This method overload and the CreateDelegate(Type, Object, MethodInfo) method overload, which always throws on failure to bind, provide the most flexible way to create delegates. Vous pouvez les utiliser pour créer des délégués pour les méthodes statiques ou d’instance, avec ou sans premier argument.You can use them to create delegates for either static or instance methods, with or without a first argument.

Notes

Si vous ne fournissez pas de premier argument, utilisez CreateDelegate(Type, MethodInfo, Boolean) la surcharge de méthode pour obtenir de meilleures performances.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo, Boolean) method overload for better performance.

Le type de délégué et la méthode doivent avoir des types de retour compatibles.The delegate type and the method must have compatible return types. Autrement dit, le type de retour method de doit pouvoir être assigné au type de retour typede.That is, the return type of method must be assignable to the return type of type.

Si firstArgument est fourni, il est passé à method chaque fois que le délégué est appelé ; firstArgument est dit être lié au délégué et le délégué est dit fermé sur son premier argument.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. Si method est static ( method firstArgument en Visual Basic), la liste d’arguments fournie lors de l’appel du délégué comprend tous les paramètres à l’exception de la première ; si est une méthode d’instance, est passé à l’instance masquéeShared paramètre (représenté par this dans C#, ou par Me dans Visual Basic).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

Si firstArgument est fourni, le premier paramètre de method doit être un type référence et firstArgument doit être compatible avec ce type.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Important

Si method est static ( Object ValueTypedans Visual Basic) et que sonfirstArgument premier paramètre est de type ou, peut être un type valeur.SharedIf method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. Dans ce cas firstArgument , est automatiquement converti (boxed).In this case firstArgument is automatically boxed. Le boxing automatique ne se produit pas pour les autres arguments, comme c’est C# le cas dans un appel de fonction ou Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Si firstArgument est une référence null et method qu’il s’agit d’une méthode d’instance, le résultat dépend des signatures type du type methoddélégué et de :If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • Si la signature de type comprend explicitement le premier paramètre masqué de method, il est dit que le délégué représente une méthode d’instance ouverte.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Lorsque le délégué est appelé, le premier argument de la liste d’arguments est passé au paramètre d’instance masqué de method.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Si les signatures de method et type correspondent (autrement dit, tous les types de paramètres sont compatibles), le délégué est dit fermé sur une référence null.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. L’appel du délégué est semblable à l’appel d’une méthode d’instance sur une instance null, ce qui n’est pas une opération particulièrement utile.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Si firstArgument est une référence null et method est statique, le résultat dépend des signatures du type type délégué et de method:If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • Si la signature de method et type la correspondance (autrement dit, tous les types de paramètres sont compatibles), le délégué est dit qu’il s’agit d’une méthode statique ouverte.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. C’est le cas le plus courant pour les méthodes statiques.This is the most common case for static methods. Dans ce cas, vous pouvez obtenir des performances légèrement meilleures à l' CreateDelegate(Type, MethodInfo, Boolean) aide de la surcharge de méthode.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo, Boolean) method overload.

  • Si la signature de type commence par le deuxième paramètre de method et que le reste des types de paramètres est compatible, le délégué est dit fermé sur une référence null.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. Lorsque le délégué est appelé, une référence null est passée au premier paramètre de method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Types de paramètres et type de retour compatiblesCompatible Parameter Types and Return Type

Les types de paramètres et le type de retour d’un délégué doivent être compatibles avec les types de paramètres et le type de retour de la méthode que le délégué représente ; les types ne doivent pas nécessairement correspondre exactement.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Notes

Dans les .NET Framework version 1,0 et 1,1, les types doivent correspondre exactement.In the .NET Framework version 1.0 and 1.1 the types must match exactly.

Le paramètre d'un délégué est compatible avec le paramètre correspondant d'une méthode si le type de paramètre du délégué est plus restrictif que le type de paramètre de la méthode. En effet, cela garantit qu'un argument transmis au délégué peut être transmis à la méthode en toute sécurité.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

De même, le type de retour d’un délégué est compatible avec le type de retour d’une méthode si le type de retour de la méthode est plus restrictif que le type de retour du délégué, car cela garantit que le cast de la valeur de retour de la méthode peut être effectué sans risque au type de retour du délégué.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Par exemple, un délégué avec un paramètre de type Hashtable et un type de Object retour peut représenter une méthode avec un paramètre de type Object et une valeur de retour de Hashtabletype.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Détermination des méthodes qu’un délégué peut représenterDetermining the Methods a Delegate Can Represent

Une autre façon utile de considérer la flexibilité fournie par cette surcharge de CreateDelegate est qu’un délégué donné peut représenter quatre combinaisons différentes de la signature de méthode et du genre de méthode (statique et instance).Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). Imaginez un type D délégué avec un argument de type C.Consider a delegate type D with one argument of type C. L’exemple suivant décrit les D méthodes qui peuvent être représentées, en ignorant le type de retour, car il doit correspondre dans tous les cas :The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • Dpeut représenter n’importe quelle méthode d’instance ayant exactement un argument Cde type, quel que soit le type auquel la méthode d’instance appartient.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Lorsque CreateDelegate est appelé, firstArgument est une instance du type method qui appartient à, et le délégué obtenu est dit fermé sur cette instance.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (Trifiolement, D peut également être fermé sur une référence null si firstArgument est null.)(Trivially, D can also be closed over a null reference if firstArgument is null.)

  • Dpeut représenter une méthode d’instance C de qui n’a pas d’arguments.D can represent an instance method of C that has no arguments. Lorsque CreateDelegate est appelé, firstArgument est une référence null.When CreateDelegate is called, firstArgument is a null reference. Le délégué résultant représente une méthode d’instance ouverte, et une instance C de doit être fournie à chaque fois qu’il est appelé.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • Dpeut représenter une méthode statique qui accepte un argument de type C, et cette méthode peut appartenir à n’importe quel type.D can represent a static method that takes one argument of type C, and that method can belong to any type. Lorsque CreateDelegate est appelé, firstArgument est une référence null.When CreateDelegate is called, firstArgument is a null reference. Le délégué obtenu représente une méthode statique ouverte, et une instance de C doit être fournie chaque fois qu’elle est appelée.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • Dpeut représenter une méthode statique qui appartient au type F et a deux arguments, de type F et Cde type.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Lorsque CreateDelegate est appelé, firstArgument est une instance de F.When CreateDelegate is called, firstArgument is an instance of F. Le délégué résultant représente une méthode statique fermée sur cette instance de F.The resulting delegate represents a static method that is closed over that instance of F. Notez que dans le cas où F et C sont du même type, la méthode statique a deux arguments de ce type.Note that in the case where F and C are the same type, the static method has two arguments of that type. (Dans ce cas, D est fermé sur une référence null si firstArgument est null.)(In this case, D is closed over a null reference if firstArgument is null.)

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

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

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Object

Instance de classe sur laquelle la méthode method est appelée.The class instance on which method is invoked.

method
String

Nom de la méthode d’instance que doit représenter le délégué.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Valeur booléenne indiquant si la casse doit être ignorée pendant la comparaison du nom de la méthode.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true pour lever une exception si method ne peut pas être lié ; sinon, false.true to throw an exception if method cannot be bound; otherwise, false.

Retours

Délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceptions

type a la valeur null.type is null.

- ou --or- target a la valeur null.target is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

ou-or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

ou-or- method n’est pas une méthode d’instance.method is not an instance method.

- ou --or- method ne peut pas être lié, par exemple car elle est introuvable, et throwOnBindFailure a la valeur true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes d’instance uniquement.This method creates delegates for instance methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, MethodInfo, Boolean)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée, avec le comportement spécifié en cas d'échec de la liaison.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Reflection::MethodInfo ^ method, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * System.Reflection.MethodInfo * bool -> Delegate

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

method
MethodInfo

MethodInfo décrivant la méthode statique ou d’instance que le délégué doit représenter.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true pour lever une exception si method ne peut pas être lié ; sinon, false.true to throw an exception if method cannot be bound; otherwise, false.

Retours

Délégué du type spécifié pour représenter la méthode statique spécifiée.A delegate of the specified type to represent the specified static method.

Exceptions

type a la valeur null.type is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

ou-or- method ne peut pas être lié et throwOnBindFailure a la valeur true.method cannot be bound, and throwOnBindFailure is true.

ou-or- method n’est pas un RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Exemples

Cette section contient deux exemples de code.This section contains two code examples. Le premier exemple illustre les deux genres de délégués qui peuvent être créés avec cette surcharge de méthode : ouvert sur une méthode d’instance et ouvert sur une méthode statique.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

Le deuxième exemple de code illustre les types de paramètres compatibles et les types de retour.The second code example demonstrates compatible parameter types and return types.

Exemple 1Example 1

L’exemple de code suivant montre les deux façons dont un délégué peut être créé à l’aide CreateDelegate de cette surcharge de la méthode.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient MethodInfo un, mais pas un premier argument. leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple déclare C une classe avec une méthode M2 statique et une méthode M1d’instance, et deux types délégués : D1 prend une instance de C et une chaîne, et D2 prend une chaîne.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

Une deuxième classe nommée Example contient le code qui crée les délégués.A second class named Example contains the code that creates the delegates.

  • Un délégué de type D1, qui représente une méthode d’instance ouverte, est créé pour la M1méthode d’instance.A delegate of type D1, representing an open instance method, is created for the instance method M1. Une instance doit être passée lorsque le délégué est appelé.An instance must be passed when the delegate is invoked.

  • Un délégué de type D2, représentant une méthode statique ouverte, est créé pour la méthode M2statique.A delegate of type D2, representing an open static method, is created for the static method M2.

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

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

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

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

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

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

        D1 d1;
        D2 d2;
        D3 d3;


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

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

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


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

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


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

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


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

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

/* This code example produces the following output:

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

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

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

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

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

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

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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

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

Exemple 2Example 2

L’exemple de code suivant illustre la compatibilité des types de paramètres et des types de retour.The following code example demonstrates compatibility of parameter types and return types.

Notes

Cet exemple de code utilise CreateDelegate(Type, MethodInfo) la surcharge de méthode.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L’utilisation d’autres surcharges qui prennent MethodInfo sont similaires.The use of other overloads that take MethodInfo is similar.

L’exemple de code définit une classe de Base base nommée et une Derived classe nommée qui dérive de Base.The code example defines a base class named Base and a class named Derived that derives from Base. La classe dérivée a static uneShared méthode (dans Visual Basic) MyMethod nommée avec un paramètre de Base type et un type de Derivedretour.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. L’exemple de code définit également un délégué Example nommé qui a un paramètre de Derived type et un type de Baseretour.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

L’exemple de code montre que le délégué Example nommé peut être utilisé pour représenter la MyMethodméthode.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. La méthode peut être liée au délégué, car :The method can be bound to the delegate because:

  • Le type de paramètre du délégué (Derived) est plus restrictif que le type de paramètre MyMethod deBase(), afin qu’il soit toujours sûr de passer l’argument du délégué à MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Le type de retour MyMethod deDerived() est plus restrictif que le type de paramètre du déléguéBase(), de sorte qu’il est toujours sûr d’effectuer un cast du type de retour de la méthode vers le type de retour du délégué.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

L’exemple de code ne produit pas de sortie.The code example produces no output.

using namespace System;
using namespace System::Reflection;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Derived
    Inherits Base

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

End Class

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

Module Test

    Sub Main()

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

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

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

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

Remarques

Cette surcharge de méthode peut créer des délégués de méthode statiques ouverts et des délégués de méthode d’instance ouverts, c’est-à-dire des délégués qui exposent le premier argument masqué de méthodes d’instance.This method overload can create open static method delegates and open instance method delegates - that is, delegates that expose the hidden first argument of instance methods. Pour obtenir une explication détaillée, consultez la surcharge CreateDelegate(Type, Object, MethodInfo, Boolean) de méthode plus générale, qui vous permet de créer toutes les combinaisons de délégués ouverts ou fermés pour les méthodes d’instance ou statiques.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo, Boolean) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods.

Notes

Cette surcharge de méthode doit être utilisée lorsque le délégué n’est pas fermé sur son premier argument, car il est un peu plus rapide dans ce cas.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Types de paramètres et type de retour compatiblesCompatible Parameter Types and Return Type

Les types de paramètres et le type de retour d’un délégué doivent être compatibles avec les types de paramètres et le type de retour de la méthode que le délégué représente ; les types ne doivent pas nécessairement correspondre exactement.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Notes

Dans les .NET Framework version 1,0 et 1,1, les types doivent correspondre exactement.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Le paramètre d'un délégué est compatible avec le paramètre correspondant d'une méthode si le type de paramètre du délégué est plus restrictif que le type de paramètre de la méthode. En effet, cela garantit qu'un argument transmis au délégué peut être transmis à la méthode en toute sécurité.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

De même, le type de retour d’un délégué est compatible avec le type de retour d’une méthode si le type de retour de la méthode est plus restrictif que le type de retour du délégué, car cela garantit que le cast de la valeur de retour de la méthode peut être effectué sans risque au type de retour du délégué.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Par exemple, un délégué avec un paramètre de type Hashtable et un type de Object retour peut représenter une méthode avec un paramètre de type Object et une valeur de retour de Hashtabletype.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Object, String)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Object

Instance de classe sur laquelle la méthode method est appelée.The class instance on which method is invoked.

method
String

Nom de la méthode d’instance que doit représenter le délégué.The name of the instance method that the delegate is to represent.

Retours

Délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceptions

type a la valeur null.type is null.

- ou --or- target a la valeur null.target is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

ou-or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

- ou --or- method n’est pas une méthode d’instance.method is not an instance method.

ou-or- method ne peut pas être lié, ce qui peut arriver s’il est introuvable.method cannot be bound, for example because it cannot be found.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes d’instance uniquement.This method creates delegates for instance methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Cette surcharge de méthode équivaut à appeler la CreateDelegate(Type, Object, String, Boolean, Boolean) surcharge de méthode, false en ignoreCase spécifiant throwOnBindFailurepour et true pour.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Object, MethodInfo)

Crée un délégué du type spécifié qui représente la méthode statique ou méthode d'instance spécifiée, avec le premier argument spécifié.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

firstArgument
Object

Objet auquel le délégué est lié, ou null si method est traitée comme static (Shared en Visual Basic).The object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo

MethodInfo décrivant la méthode statique ou d’instance que le délégué doit représenter.The MethodInfo describing the static or instance method the delegate is to represent.

Retours

Délégué du type spécifié qui représente la méthode statique ou méthode d’instance spécifiée.A delegate of the specified type that represents the specified static or instance method.

Exceptions

type a la valeur null.type is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

ou-or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

ou-or- method ne peut pas être liée.method cannot be bound.

- ou --or- method n’est pas un RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Exemples

Cette section contient trois exemples de code.This section contains three code examples. Le premier exemple montre les quatre genres de délégués qui peuvent être créés : fermés sur une méthode d’instance, ouverts sur une méthode d’instance, ouverts sur une méthode statique et fermés sur une méthode statique.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

Le deuxième exemple de code illustre les types de paramètres compatibles et les types de retour.The second code example demonstrates compatible parameter types and return types.

Le troisième exemple de code définit un type délégué unique et affiche toutes les méthodes que le type délégué peut représenter.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Exemple 1Example 1

L’exemple de code suivant montre les quatre façons dont un délégué peut être créé à l’aide CreateDelegate de cette surcharge de la méthode.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient firstArgument et MethodInfoa ; leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple déclare C une classe avec une méthode M2 statique et une méthode M1d’instance, et trois types délégués : D1 prend une instance de C et une chaîne, D2 prend une chaîne et D3n’a pas d’arguments.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

Une deuxième classe nommée Example contient le code qui crée les délégués.A second class named Example contains the code that creates the delegates.

  • Un délégué de type D2, fermé sur une instance de C, est créé pour la méthode M1d’instance.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Elle est appelée avec des chaînes différentes, pour indiquer que l’instance liée de C est toujours utilisée.It is invoked with different strings, to show that the bound instance of C is always used.

  • Un délégué de type D1, qui représente une méthode d’instance ouverte, est créé pour la M1méthode d’instance.A delegate of type D1, representing an open instance method, is created for the instance method M1. Une instance doit être passée lorsque le délégué est appelé.An instance must be passed when the delegate is invoked.

  • Un délégué de type D2, représentant une méthode statique ouverte, est créé pour la méthode M2statique.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Enfin, un délégué de type D3, fermé sur une chaîne, est créé pour la méthode M2statique.Finally, a delegate of type D3, closed over a string, is created for the static method M2. La méthode est appelée pour montrer qu’elle utilise la chaîne liée.The method is invoked to show that it uses the bound string.

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

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

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

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

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

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

        D1 d1;
        D2 d2;
        D3 d3;


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

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

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


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

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


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

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


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

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

/* This code example produces the following output:

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

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

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

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

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

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

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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

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

Exemple 2Example 2

L’exemple de code suivant illustre la compatibilité des types de paramètres et des types de retour.The following code example demonstrates compatibility of parameter types and return types.

Notes

Cet exemple de code utilise CreateDelegate(Type, MethodInfo) la surcharge de méthode.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L’utilisation d’autres surcharges qui prennent MethodInfo sont similaires.The use of other overloads that take MethodInfo is similar.

L’exemple de code définit une classe de Base base nommée et une Derived classe nommée qui dérive de Base.The code example defines a base class named Base and a class named Derived that derives from Base. La classe dérivée a static uneShared méthode (dans Visual Basic) MyMethod nommée avec un paramètre de Base type et un type de Derivedretour.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. L’exemple de code définit également un délégué Example nommé qui a un paramètre de Derived type et un type de Baseretour.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

L’exemple de code montre que le délégué Example nommé peut être utilisé pour représenter la MyMethodméthode.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. La méthode peut être liée au délégué, car :The method can be bound to the delegate because:

  • Le type de paramètre du délégué (Derived) est plus restrictif que le type de paramètre MyMethod deBase(), afin qu’il soit toujours sûr de passer l’argument du délégué à MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Le type de retour MyMethod deDerived() est plus restrictif que le type de paramètre du déléguéBase(), de sorte qu’il est toujours sûr d’effectuer un cast du type de retour de la méthode vers le type de retour du délégué.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

L’exemple de code ne produit pas de sortie.The code example produces no output.

using namespace System;
using namespace System::Reflection;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Derived
    Inherits Base

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

End Class

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

Module Test

    Sub Main()

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

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

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

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

Exemple 3Example 3

L’exemple de code suivant montre toutes les méthodes qu’un type délégué unique peut représenter, CreateDelegate à l’aide de la méthode pour créer les délégués.The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient firstArgument et MethodInfoa ; leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple de code définit deux classes C , Fet, et un type D délégué avec un argument de Ctype.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Les classes ont M1des méthodes d’instance et statiques correspondantes, M3, C et M4, et la classe M2 a également une méthode d’instance qui n’a pas d’arguments.The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

Une troisième classe nommée Example contient le code qui crée les délégués.A third class named Example contains the code that creates the delegates.

  • Les délégués sont créés pour une M1 méthode d' C instance de Ftype et de type ; chacun est fermé sur une instance du type respectif.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Méthode M1 de type C affiche les ID propriétés de l’instance liée et de l’argument.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Un délégué est créé pour la M2 méthode de Ctype.A delegate is created for method M2 of type C. Il s’agit d’un délégué d’instance ouvert, dans lequel l’argument du délégué représente le premier argument masqué sur la méthode d’instance.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. La méthode n’a pas d’autres arguments.The method has no other arguments. Elle est appelée comme s’il s’agissait d’une méthode statique.It is called as if it were a static method.

  • Les délégués sont créés pour une M3 méthode statique C de type Fet de type ; il s’agit de délégués statiques ouverts.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Enfin, les délégués sont créés pour une M4 méthode statique C de type Fet de type ; chaque méthode a le type déclarant comme premier argument et une instance du type est fournie, donc les délégués sont fermés sur leurs premiers arguments. .Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. Méthode M4 de type C affiche les ID propriétés de l’instance liée et de l’argument.Method M4 of type C displays the ID properties of the bound instance and of the argument.

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

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

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

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

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

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

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


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

        D d;

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

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

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

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

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

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

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

/* This code example produces the following output:

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

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

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

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

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

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

    Private _id As Integer

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

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


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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

Remarques

L’appel de cette surcharge de méthode équivaut à CreateDelegate(Type, Object, MethodInfo, Boolean) appeler la surcharge de true méthode throwOnBindFailureet à spécifier pour.Calling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. Ces deux surcharges offrent la méthode la plus souple pour créer des délégués.These two overloads provide the most flexible way to create delegates. Vous pouvez les utiliser pour créer des délégués pour les méthodes statiques ou d’instance, et éventuellement pour spécifier le premier argument.You can use them to create delegates for either static or instance methods, and optionally to specify the first argument.

Notes

Si vous ne fournissez pas de premier argument, utilisez CreateDelegate(Type, MethodInfo) la surcharge de méthode pour obtenir de meilleures performances.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo) method overload for better performance.

Le type de délégué et la méthode doivent avoir des types de retour compatibles.The delegate type and the method must have compatible return types. Autrement dit, le type de retour method de doit pouvoir être assigné au type de retour typede.That is, the return type of method must be assignable to the return type of type.

Si firstArgument est fourni, il est passé à method chaque fois que le délégué est appelé ; firstArgument est dit être lié au délégué et le délégué est dit fermé sur son premier argument.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. Si method est static ( method firstArgument en Visual Basic), la liste d’arguments fournie lors de l’appel du délégué comprend tous les paramètres à l’exception de la première ; si est une méthode d’instance, est passé à l’instance masquéeShared paramètre (représenté par this dans C#, ou par Me dans Visual Basic).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

Si firstArgument est fourni, le premier paramètre de method doit être un type référence et firstArgument doit être compatible avec ce type.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Important

Si method est static ( Object ValueTypedans Visual Basic) et que sonfirstArgument premier paramètre est de type ou, peut être un type valeur.SharedIf method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. Dans ce cas firstArgument , est automatiquement converti (boxed).In this case firstArgument is automatically boxed. Le boxing automatique ne se produit pas pour les autres arguments, comme c’est C# le cas dans un appel de fonction ou Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Si firstArgument est une référence null et method qu’il s’agit d’une méthode d’instance, le résultat dépend des signatures type du type methoddélégué et de :If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • Si la signature de type comprend explicitement le premier paramètre masqué de method, il est dit que le délégué représente une méthode d’instance ouverte.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Lorsque le délégué est appelé, le premier argument de la liste d’arguments est passé au paramètre d’instance masqué de method.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Si les signatures de method et type correspondent (autrement dit, tous les types de paramètres sont compatibles), le délégué est dit fermé sur une référence null.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. L’appel du délégué est semblable à l’appel d’une méthode d’instance sur une instance null, ce qui n’est pas une opération particulièrement utile.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Si firstArgument est une référence null et method est statique, le résultat dépend des signatures du type type délégué et de method:If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • Si la signature de method et type la correspondance (autrement dit, tous les types de paramètres sont compatibles), le délégué est dit qu’il s’agit d’une méthode statique ouverte.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. C’est le cas le plus courant pour les méthodes statiques.This is the most common case for static methods. Dans ce cas, vous pouvez obtenir des performances légèrement meilleures à l' CreateDelegate(Type, MethodInfo) aide de la surcharge de méthode.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo) method overload.

  • Si la signature de type commence par le deuxième paramètre de method et que le reste des types de paramètres est compatible, le délégué est dit fermé sur une référence null.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. Lorsque le délégué est appelé, une référence null est passée au premier paramètre de method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Types de paramètres et type de retour compatiblesCompatible Parameter Types and Return Type

Les types de paramètres et le type de retour d’un délégué doivent être compatibles avec les types de paramètres et le type de retour de la méthode que le délégué représente ; les types ne doivent pas nécessairement correspondre exactement.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Notes

Dans les .NET Framework version 1,0 et 1,1, les types doivent correspondre exactement.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Le paramètre d'un délégué est compatible avec le paramètre correspondant d'une méthode si le type de paramètre du délégué est plus restrictif que le type de paramètre de la méthode. En effet, cela garantit qu'un argument transmis au délégué peut être transmis à la méthode en toute sécurité.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

De même, le type de retour d’un délégué est compatible avec le type de retour d’une méthode si le type de retour de la méthode est plus restrictif que le type de retour du délégué, car cela garantit que le cast de la valeur de retour de la méthode peut être effectué sans risque au type de retour du délégué.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Par exemple, un délégué avec un paramètre de type Hashtable et un type de Object retour peut représenter une méthode avec un paramètre de type Object et une valeur de retour de Hashtabletype.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Détermination des méthodes qu’un délégué peut représenterDetermining the Methods a Delegate Can Represent

Une autre façon utile de considérer la flexibilité fournie par cette surcharge de CreateDelegate est qu’un délégué donné peut représenter quatre combinaisons différentes de la signature de méthode et du genre de méthode (statique et instance).Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). Imaginez un type D délégué avec un argument de type C.Consider a delegate type D with one argument of type C. L’exemple suivant décrit les D méthodes qui peuvent être représentées, en ignorant le type de retour, car il doit correspondre dans tous les cas :The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • Dpeut représenter n’importe quelle méthode d’instance ayant exactement un argument Cde type, quel que soit le type auquel la méthode d’instance appartient.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Lorsque CreateDelegate est appelé, firstArgument est une instance du type method qui appartient à, et le délégué obtenu est dit fermé sur cette instance.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (De façon triviale D , peut également être fermé sur une référence null firstArgument si est une référence null.)(Trivially, D can also be closed over a null reference if firstArgument is a null reference.)

  • Dpeut représenter une méthode d’instance C de qui n’a pas d’arguments.D can represent an instance method of C that has no arguments. Lorsque CreateDelegate est appelé, firstArgument est une référence null.When CreateDelegate is called, firstArgument is a null reference. Le délégué résultant représente une méthode d’instance ouverte, et une instance C de doit être fournie à chaque fois qu’il est appelé.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • Dpeut représenter une méthode statique qui accepte un argument de type C, et cette méthode peut appartenir à n’importe quel type.D can represent a static method that takes one argument of type C, and that method can belong to any type. Lorsque CreateDelegate est appelé, firstArgument est une référence null.When CreateDelegate is called, firstArgument is a null reference. Le délégué obtenu représente une méthode statique ouverte, et une instance de C doit être fournie chaque fois qu’elle est appelée.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • Dpeut représenter une méthode statique qui appartient au type F et a deux arguments, de type F et Cde type.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Lorsque CreateDelegate est appelé, firstArgument est une instance de F.When CreateDelegate is called, firstArgument is an instance of F. Le délégué résultant représente une méthode statique fermée sur cette instance de F.The resulting delegate represents a static method that is closed over that instance of F. Notez que dans le cas où F et C sont du même type, la méthode statique a deux arguments de ce type.Note that in the case where F and C are the same type, the static method has two arguments of that type. (Dans ce cas, D est fermé sur une référence null si firstArgument est une référence null.)(In this case, D is closed over a null reference if firstArgument is a null reference.)

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, Type, String)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.Creates a delegate of the specified type that represents the specified static method of the specified class.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

target
Type

Type représentant la classe qui implémente method.The Type representing the class that implements method.

method
String

Nom de la méthode statique que doit représenter le délégué.The name of the static method that the delegate is to represent.

Retours

Délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.A delegate of the specified type that represents the specified static method of the specified class.

Exceptions

type a la valeur null.type is null.

- ou --or- target a la valeur null.target is null.

- ou --or- method a la valeur null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

ou-or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

- ou --or- target n'est pas un RuntimeType.target is not a RuntimeType.

- ou --or- target est un type générique ouvert.target is an open generic type. Autrement dit, sa propriété ContainsGenericParameters a la valeur true.That is, its ContainsGenericParameters property is true.

- ou --or- method n’est pas une méthode static (méthode Shared en Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- method ne peut pas être lié, par exemple car elle est introuvable, et throwOnBindFailure a la valeur true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Remarques

Cette méthode crée des délégués pour les méthodes statiques uniquement.This method creates delegates for static methods only. Une méthode d’instance est une méthode associée à une instance d’une classe ; une méthode statique est une méthode associée à la classe elle-même.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Cette surcharge de méthode équivaut à appeler la CreateDelegate(Type, Type, String, Boolean, Boolean) surcharge de méthode, false en ignoreCase spécifiant throwOnBindFailurepour et true pour.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

CreateDelegate(Type, MethodInfo)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée.Creates a delegate of the specified type to represent the specified static method.

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

Paramètres

type
Type

Type de délégué à créer.The Type of delegate to create.

method
MethodInfo

MethodInfo décrivant la méthode statique ou d’instance que le délégué doit représenter.The MethodInfo describing the static or instance method the delegate is to represent. Seules les méthodes statiques sont prises en charge dans les versions 1.0 et 1.1 du .NET Framework.Only static methods are supported in the .NET Framework version 1.0 and 1.1.

Retours

Délégué du type spécifié pour représenter la méthode statique spécifiée.A delegate of the specified type to represent the specified static method.

Exceptions

type a la valeur null.type is null.

- ou --or- method est null.method is null.

type n’hérite pas de MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type n’est pas un RuntimeType.type is not a RuntimeType. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

ou-or- method n’est pas une méthode statique, et la version du .NET Framework est 1.0 ou 1.1.method is not a static method, and the .NET Framework version is 1.0 or 1.1.

- ou --or- method ne peut pas être liée.method cannot be bound.

- ou --or- method n’est pas un RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consultez Types au moment de l’exécution dans la réflexion.See Runtime Types in Reflection.

La méthode Invoke de type est introuvable.The Invoke method of type is not found.

L’appelant ne dispose pas des autorisations nécessaires pour accéder à method.The caller does not have the permissions necessary to access method.

Exemples

Cette section contient deux exemples de code.This section contains two code examples. Le premier exemple illustre les deux genres de délégués qui peuvent être créés avec cette surcharge de méthode : ouvert sur une méthode d’instance et ouvert sur une méthode statique.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

Le deuxième exemple de code illustre les types de paramètres compatibles et les types de retour.The second code example demonstrates compatible parameter types and return types.

Exemple 1Example 1

L’exemple de code suivant montre les deux façons dont un délégué peut être créé à l’aide CreateDelegate de cette surcharge de la méthode.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Notes

Il existe deux surcharges de la CreateDelegate méthode qui spécifient MethodInfo un, mais pas un premier argument. leurs fonctionnalités sont les mêmes, sauf que vous pouvez spécifier s’il faut lever en cas d’échec de la liaison, et l’autre lève toujours.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Cet exemple de code utilise les deux surcharges.This code example uses both overloads.

L’exemple déclare C une classe avec une méthode M2 statique et une méthode M1d’instance, et deux types délégués : D1 prend une instance de C et une chaîne, et D2 prend une chaîne.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

Une deuxième classe nommée Example contient le code qui crée les délégués.A second class named Example contains the code that creates the delegates.

  • Un délégué de type D1, qui représente une méthode d’instance ouverte, est créé pour la M1méthode d’instance.A delegate of type D1, representing an open instance method, is created for the instance method M1. Une instance doit être passée lorsque le délégué est appelé.An instance must be passed when the delegate is invoked.

  • Un délégué de type D2, représentant une méthode statique ouverte, est créé pour la méthode M2statique.A delegate of type D2, representing an open static method, is created for the static method M2.

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

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

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

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

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

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

        D1 d1;
        D2 d2;
        D3 d3;


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

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

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


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

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


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

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


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

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

/* This code example produces the following output:

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

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

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

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

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

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

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

Public Class Example
    
    Public Shared Sub Main() 

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

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

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

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

Exemple 2Example 2

L’exemple de code suivant illustre la compatibilité des types de paramètres et des types de retour.The following code example demonstrates compatibility of parameter types and return types.

L’exemple de code définit une classe de Base base nommée et une Derived classe nommée qui dérive de Base.The code example defines a base class named Base and a class named Derived that derives from Base. La classe dérivée a static uneShared méthode (dans Visual Basic) MyMethod nommée avec un paramètre de Base type et un type de Derivedretour.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. L’exemple de code définit également un délégué Example nommé qui a un paramètre de Derived type et un type de Baseretour.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

L’exemple de code montre que le délégué Example nommé peut être utilisé pour représenter la MyMethodméthode.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. La méthode peut être liée au délégué, car :The method can be bound to the delegate because:

  • Le type de paramètre du délégué (Derived) est plus restrictif que le type de paramètre MyMethod deBase(), afin qu’il soit toujours sûr de passer l’argument du délégué à MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Le type de retour MyMethod deDerived() est plus restrictif que le type de paramètre du déléguéBase(), de sorte qu’il est toujours sûr d’effectuer un cast du type de retour de la méthode vers le type de retour du délégué.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

L’exemple de code ne produit pas de sortie.The code example produces no output.

using namespace System;
using namespace System::Reflection;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Derived
    Inherits Base

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

End Class

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

Module Test

    Sub Main()

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

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

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

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

Remarques

Dans la version 1,0 et 1,1 de la .NET Framework, cette surcharge de méthode crée des délégués pour les méthodes statiques uniquement.In the .NET Framework version 1.0 and 1.1, this method overload creates delegates for static methods only. Dans la version .NET Framework 2,0, cette surcharge de méthode peut également créer des délégués de méthode d’instance ouverte. autrement dit, les délégués qui fournissent explicitement le premier argument masqué des méthodes d’instance.In the .NET Framework version 2.0, this method overload also can create open instance method delegates; that is, delegates that explicitly supply the hidden first argument of instance methods. Pour obtenir une explication détaillée, consultez la surcharge CreateDelegate(Type, Object, MethodInfo) de méthode plus générale, qui vous permet de créer toutes les combinaisons de délégués ouverts ou fermés pour les méthodes d’instance ou statiques, et de spécifier éventuellement un premier argument.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods, and optionally to specify a first argument.

Notes

Cette surcharge de méthode doit être utilisée lorsque le délégué n’est pas fermé sur son premier argument, car il est un peu plus rapide dans ce cas.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Cette surcharge de méthode équivaut à appeler la CreateDelegate(Type, MethodInfo, Boolean) surcharge de méthode et true à throwOnBindFailurespécifier pour.This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

Notes

À partir de ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess , cette méthode peut être utilisée pour accéder aux méthodes non publiques si l’appelant a reçu l’autorisation avec l’indicateur et si le jeu d’autorisations des méthodes non publiques est limité au jeu d’autorisations de l’appelant, ou à un .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1sous-ensemble parties.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Consultez Considérations sur la sécurité pour la réflexion.)(See Security Considerations for Reflection.)

Pour utiliser cette fonctionnalité, votre application doit cibler .NET Framework 3.5.NET Framework 3.5 ou version ultérieure.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Types de paramètres et type de retour compatiblesCompatible Parameter Types and Return Type

Dans la version .NET Framework 2,0, les types de paramètres et le type de retour d’un délégué créé à l’aide de cette surcharge de méthode doivent être compatibles avec les types de paramètres et le type de retour de la méthode que le délégué représente. les types ne doivent pas nécessairement correspondre exactement.In the .NET Framework version 2.0, the parameter types and return type of a delegate created using this method overload must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly. Cela représente un assouplissement du comportement de liaison dans les .NET Framework version 1,0 et 1,1, où les types doivent correspondre exactement.This represents a relaxation of the binding behavior in the .NET Framework version 1.0 and 1.1, where the types must match exactly.

Le paramètre d'un délégué est compatible avec le paramètre correspondant d'une méthode si le type de paramètre du délégué est plus restrictif que le type de paramètre de la méthode. En effet, cela garantit qu'un argument transmis au délégué peut être transmis à la méthode en toute sécurité.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

De même, le type de retour d’un délégué est compatible avec le type de retour d’une méthode si le type de retour de la méthode est plus restrictif que le type de retour du délégué, car cela garantit que le cast de la valeur de retour de la méthode peut être effectué sans risque au type de retour du délégué.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Par exemple, un délégué avec un paramètre de type Hashtable et un type de Object retour peut représenter une méthode avec un paramètre de type Object et une valeur de retour de Hashtabletype.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Sécurité

ReflectionPermission
en cas d’appel à liaison tardive via des mécanismes InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])tels que.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Énumération associée : MemberAccess.Associated enumeration: MemberAccess.

Voir aussi

S’applique à