Delegate Classe

Définition

Représente un délégué, lequel est une structure de données qui fait référence à une méthode statique ou à une instance de classe et à une méthode d'instance de cette classe.

public ref class Delegate abstract
public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable
public abstract class Delegate
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
type Delegate = class
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Delegate = class
    interface ICloneable
    interface ISerializable
Public MustInherit Class Delegate
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
Héritage
Delegate
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre comment définir un délégué nommé myMethodDelegate . Les instances de ce délégué sont créées pour une méthode d’instance et une méthode statique de la mySampleClass classe imbriquée. Le délégué de la méthode d’instance requiert une instance de mySampleClass . L' mySampleClass instance est enregistrée dans une variable nommée mySC .

using namespace System;
delegate String^ myMethodDelegate( // Declares a delegate for a method that takes in an int and returns a String.
int myInt );

// Defines some methods to which the delegate can point.
ref class mySampleClass
{
public:

   // Defines an instance method.
   String^ myStringMethod( int myInt )
   {
      if ( myInt > 0 )
            return ("positive");

      if ( myInt < 0 )
            return ("negative");

      return ("zero");
   }


   // Defines a static method.
   static String^ mySignMethod( int myInt )
   {
      if ( myInt > 0 )
            return ("+");

      if ( myInt < 0 )
            return ("-");

      return ("");
   }

};

int main()
{
   
   // Creates one delegate for each method. For the instance method, an 
   // instance (mySC) must be supplied. For the static method, only the
   // method name is needed.
   mySampleClass^ mySC = gcnew mySampleClass;
   myMethodDelegate^ myD1 = gcnew myMethodDelegate( mySC, &mySampleClass::myStringMethod );
   myMethodDelegate^ myD2 = gcnew myMethodDelegate( mySampleClass::mySignMethod );
   
   // Invokes the delegates.
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".",  -3, myD1(  -3 ), myD2(  -3 ) );
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
}

/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/
using System;
public class SamplesDelegate  {

   // Declares a delegate for a method that takes in an int and returns a string.
   public delegate string myMethodDelegate( int myInt );

   // Defines some methods to which the delegate can point.
   public class mySampleClass  {

      // Defines an instance method.
      public string myStringMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "positive" );
         if ( myInt < 0 )
            return( "negative" );
         return ( "zero" );
      }

      // Defines a static method.
      public static string mySignMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "+" );
         if ( myInt < 0 )
            return( "-" );
         return ( "" );
      }
   }

   public static void Main()  {

      // Creates one delegate for each method. For the instance method, an
      // instance (mySC) must be supplied. For the static method, use the
      // class name.
      mySampleClass mySC = new mySampleClass();
      myMethodDelegate myD1 = new myMethodDelegate( mySC.myStringMethod );
      myMethodDelegate myD2 = new myMethodDelegate( mySampleClass.mySignMethod );

      // Invokes the delegates.
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", -3, myD1( -3 ), myD2( -3 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
   }
}


/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/
Public Class SamplesDelegate

   ' Declares a delegate for a method that takes in an int and returns a String.
   Delegate Function myMethodDelegate(myInt As Integer) As [String]

   ' Defines some methods to which the delegate can point.
   Public Class mySampleClass

      ' Defines an instance method.
      Public Function myStringMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "positive"
         End If
         If myInt < 0 Then
            Return "negative"
         End If
         Return "zero"
      End Function 'myStringMethod

      ' Defines a static method.
      Public Shared Function mySignMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "+"
         End If
         If myInt < 0 Then
            Return "-"
         End If
         Return ""
      End Function 'mySignMethod
   End Class

   Public Shared Sub Main()

      ' Creates one delegate for each method. For the instance method, an
      ' instance (mySC) must be supplied. For the Shared method, the
      ' method name is qualified by the class name.
      Dim mySC As New mySampleClass()
      Dim myD1 As New myMethodDelegate(AddressOf mySC.myStringMethod)
      Dim myD2 As New myMethodDelegate(AddressOf mySampleClass.mySignMethod)

      ' Invokes the delegates.
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", 5, myD1(5), myD2(5))
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", - 3, myD1(- 3), myD2(- 3))
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", 0, myD1(0), myD2(0))

   End Sub

End Class


'This code produces the following output:
' 
'5 is positive; use the sign "+".
'-3 is negative; use the sign "-".
'0 is zero; use the sign "".

Remarques

La Delegate classe est la classe de base pour les types délégués. Toutefois, seuls le système et les compilateurs peuvent dériver explicitement à partir de la Delegate classe ou de la MulticastDelegate classe. Il n’est pas non plus possible de dériver un nouveau type à partir d’un type délégué. La Delegate classe n’est pas considérée comme un type délégué ; il s’agit d’une classe utilisée pour dériver des types délégués.

La plupart des langages implémentent un delegate mot clé, et les compilateurs pour ces langages peuvent dériver de la MulticastDelegate classe ; par conséquent, les utilisateurs doivent utiliser le delegate mot clé fourni par le langage.

Notes

L’common language runtime fournit une Invoke méthode pour chaque type délégué, avec la même signature que le délégué. vous n’avez pas à appeler cette méthode explicitement à partir de C#, Visual Basic ou Visual C++, car les compilateurs l’appellent automatiquement. La Invoke méthode est utile dans la réflexion lorsque vous souhaitez rechercher la signature du type délégué.

L’common language runtime fournit chaque type délégué avec BeginInvoke les EndInvoke méthodes et, afin d’activer l’appel asynchrone du délégué. Pour plus d’informations sur ces méthodes, consultez appel de méthodes synchrones de façon asynchrone.

La déclaration d’un type délégué établit un contrat qui spécifie la signature d’une ou plusieurs méthodes. Un délégué est une instance d’un type délégué qui a des références à :

  • Une méthode d’instance d’un type et un objet cible pouvant être assigné à ce type.

  • Méthode d’instance d’un type, avec le this paramètre Hidden exposé dans la liste de paramètres formels. Le délégué est considéré comme un délégué d’instance ouvert.

  • Méthode statique.

  • Une méthode statique et un objet cible assignables au premier paramètre de la méthode. On dit que le délégué est fermé sur son premier argument.

Pour plus d’informations sur la liaison de délégués, consultez la CreateDelegate(Type, Object, MethodInfo, Boolean) surcharge de méthode.

Notes

dans les versions 1,0 et 1,1 du .NET Framework, un délégué peut représenter une méthode uniquement si la signature de la méthode correspond exactement à la signature spécifiée par le type délégué. Ainsi, seules les première et troisième puces de la liste précédente sont prises en charge, et la première puce requiert une correspondance exacte de type.

Lorsqu’un délégué représente une méthode d’instance fermée sur son premier argument (le cas le plus courant), le délégué stocke une référence au point d’entrée de la méthode et une référence à un objet, appelée la cible, qui est un type assignable au type qui a défini la méthode. Lorsqu’un délégué représente une méthode d’instance ouverte, il stocke une référence au point d’entrée de la méthode. La signature du délégué doit inclure le this paramètre Hidden dans sa liste de paramètres formels. dans ce cas, le délégué n’a pas de référence à un objet cible et un objet cible doit être fourni lorsque le délégué est appelé.

Lorsqu’un délégué représente une méthode statique, le délégué stocke une référence au point d’entrée de la méthode. Lorsqu’un délégué représente une méthode statique fermée sur son premier argument, le délégué stocke une référence au point d’entrée de la méthode et une référence à un objet cible qui est assignée au type du premier argument de la méthode. Lorsque le délégué est appelé, le premier argument de la méthode statique reçoit l’objet cible. Ce premier argument doit être un type référence.

La liste d’appel d’un délégué est un ensemble ordonné de délégués dans lequel chaque élément de la liste appelle exactement l’une des méthodes représentées par le délégué. Une liste d’appel peut contenir des méthodes dupliquées. Pendant un appel, les méthodes sont appelées dans l’ordre dans lequel elles apparaissent dans la liste d’appel. Un délégué tente d’appeler chaque méthode dans sa liste d’appel ; les doublons sont appelés une fois pour chaque fois qu’ils apparaissent dans la liste d’appel. Les délégués sont immuables ; une fois créé, la liste d’appel d’un délégué ne change pas.

Les délégués sont appelés multidiffusion ou combinable, car un délégué peut appeler une ou plusieurs méthodes et peut être utilisé pour combiner des opérations.

La combinaison d’opérations, telles que Combine et Remove , ne modifie pas les délégués existants. Au lieu de cela, une telle opération retourne un nouveau délégué qui contient les résultats de l’opération, un délégué inchangé ou null . Une opération d’association retourne null lorsque le résultat de l’opération est un délégué qui ne fait pas référence à au moins une méthode. Une opération d’association retourne un délégué non modifié lorsque l’opération demandée n’a aucun effet.

Notes

Les langages managés utilisent les Combine Remove méthodes et pour implémenter des opérations de délégué. les exemples incluent AddHandler les RemoveHandler instructions et dans Visual Basic et les opérateurs + = et-= sur les types délégués en C#.

à partir du .NET Framework 4, les types délégués génériques peuvent avoir des paramètres de type variant. Les paramètres de type contravariant peuvent être utilisés comme types de paramètres du délégué, et un paramètre de type covariant peut être utilisé comme type de retour. Cette fonctionnalité permet aux types délégués génériques construits à partir de la même définition de type générique d’être compatibles avec l’assignation si leurs arguments de type sont des types référence avec une relation d’héritage, comme expliqué dans covariance et contravariance.

Notes

Les délégués génériques qui sont compatibles avec l’assignation en raison de la variance ne sont pas nécessairement combinables. Pour être combinable, les types doivent correspondre exactement. Par exemple, supposons qu’une classe nommée Derived est dérivée d’une classe nommée Base . un délégué de type Action<Base> ( Action(Of Base) dans Visual Basic) peut être assigné à une variable de type Action<Derived> , mais les deux délégués ne peuvent pas être combinés, car les types ne correspondent pas exactement.

Si une méthode appelée lève une exception, la méthode cesse de s’exécuter, l’exception est repassée à l’appelant du délégué, et les méthodes restantes de la liste d’appel ne sont pas appelées. L’interception de l’exception dans l’appelant ne modifie pas ce comportement.

Lorsque la signature des méthodes appelées par un délégué comprend une valeur de retour, le délégué retourne la valeur de retour du dernier élément de la liste d’appel. Lorsque la signature comprend un paramètre passé par référence, la valeur finale du paramètre est le résultat de chaque méthode de la liste d’appel qui s’exécute de manière séquentielle et met à jour la valeur du paramètre.

L’équivalent le plus proche d’un délégué en C est un pointeur de fonction. Un délégué peut représenter une méthode statique ou une méthode d’instance. Lorsque le délégué représente une méthode d’instance, le délégué stocke non seulement une référence au point d’entrée de la méthode, mais également une référence à l’instance de classe. Contrairement aux pointeurs de fonction, les délégués sont orientés objet et de type sécurisé.

Constructeurs

Delegate(Object, String)

Initialise un délégué qui appelle la méthode d'instance spécifiée sur l'instance de classe spécifiée.

Delegate(Type, String)

Initialise un délégué qui appelle la méthode statique spécifiée à partir de la classe spécifiée.

Propriétés

Method

Obtient la méthode représentée par le délégué.

Target

Obtient l'instance de classe sur laquelle le délégué actuel appelle la méthode d'instance.

Méthodes

Clone()

Crée une copie superficielle du délégué.

Combine(Delegate, Delegate)

Concatène les listes d'appel de deux délégués.

Combine(Delegate[])

Concatène les listes d'appel d'un tableau de délégués.

CombineImpl(Delegate)

Concatène les listes d'appel du délégué multicast (pouvant être combiné) spécifié et du délégué multicast (pouvant être combiné) actuel.

CreateDelegate(Type, MethodInfo)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée.

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.

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é.

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.

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.

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é.

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.

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.

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é.

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.

DynamicInvoke(Object[])

Appelle de manière dynamique (avec liaison tardive) la méthode représentée par le délégué actuel.

DynamicInvokeImpl(Object[])

Appelle de manière dynamique (avec liaison tardive) la méthode représentée par le délégué actuel.

Equals(Object)

Détermine si l'objet spécifié et le délégué actuel sont du même type et partagent les mêmes cibles, méthodes et liste d'appel.

GetHashCode()

Retourne un code de hachage pour le délégué.

GetInvocationList()

Retourne la liste d'appel du délégué.

GetMethodImpl()

Obtient la méthode statique représentée par le délégué actuel.

GetObjectData(SerializationInfo, StreamingContext)

Non pris en charge.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
Remove(Delegate, Delegate)

Supprime la dernière occurrence de la liste d'appel d'un délégué dans la liste d'appel d'un autre délégué.

RemoveAll(Delegate, Delegate)

Supprime toutes les occurrences de la liste d'appel d'un délégué dans la liste d'appel d'un autre délégué.

RemoveImpl(Delegate)

Supprime la liste d'appel d'un délégué de la liste d'appel d'un autre délégué.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Opérateurs

Equality(Delegate, Delegate)

Détermine si les délégués spécifiés sont égaux.

Inequality(Delegate, Delegate)

Détermine si les délégués spécifiés ne sont pas égaux.

Méthodes d’extension

GetMethodInfo(Delegate)

Obtient un objet qui représente la méthode représentée par le délégué spécifié.

S’applique à

Voir aussi