Assembly : mscorlib (dans mscorlib.dll)
Syntaxe<SerializableAttribute> _ <ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _ <ComVisibleAttribute(True)> _ Public MustInherit Class Delegate Implements ICloneable, ISerializable
Dim instance As Delegate
[SerializableAttribute] [ClassInterfaceAttribute(ClassInterfaceType.AutoDual)] [ComVisibleAttribute(true)] public abstract class Delegate : ICloneable, ISerializable
[SerializableAttribute] [ClassInterfaceAttribute(ClassInterfaceType::AutoDual)] [ComVisibleAttribute(true)] public ref class Delegate abstract : ICloneable, ISerializable
/** @attribute SerializableAttribute() */ /** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */ /** @attribute ComVisibleAttribute(true) */ public abstract class Delegate implements ICloneable, ISerializable
SerializableAttribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) ComVisibleAttribute(true) public abstract class Delegate implements ICloneable, ISerializable
NotesLa classe Delegate est la classe de base pour les types délégués. Toutefois, seuls le système et les compilateurs peuvent dériver de manière explicite de la classe Delegate ou MulticastDelegate. En outre, il n'est pas possible de dériver un nouveau type d'un type délégué. La classe Delegate 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 mot clé delegate, permettant à leurs compilateurs de dériver de la classe MulticastDelegate. Par conséquent, les utilisateurs doivent utiliser le mot clé delegate fourni par le langage.
La déclaration d'un type délégué établit un contrat qui spécifie la signature d'une ou de plusieurs méthodes. Un délégué est une instance de type délégué qui contient des références à :
-
Une méthode d'instance d'un type et un objet cible pouvant être assignés à ce type.
-
Une méthode d'instance d'un type, avec le paramètre this masqué exposé dans la liste de paramètres formels. Le délégué est dit délégué d'instance ouvert.
-
Une méthode statique.
-
Une méthode statique et un objet cible pouvant être assignés au premier paramètre de la méthode. Le délégué est dit fermé sur son premier argument.
Pour plus d'informations sur la liaison de délégués, consultez Délégués du système de type commun (CTS, Common Type System) et CreateDelegate(Type,Object,MethodInfo,Boolean).
Remarque |
|---|
| Dans les versions 1.0 et 1.1 du .NET Framework, un délégué ne peut représenter une méthode que 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 de type exacte. |
Lorsqu'un délégué représente une méthode d'instance fermée sur son premier argument (le cas le plus commun), 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, nommé cible, qui est d'un type qui peut être assigné 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 paramètre this masqué dans sa liste de paramètres formels ; dans ce cas, le délégué ne contient 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, il 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 pouvant être assigné 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.
La liste d'appel d'un délégué est un ensemble ordonné de délégués dont 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. Lors d'un appel, les méthodes sont appelées dans l'ordre dans lequel elles figurent dans la liste d'appel. Un délégué tente d'appeler chaque méthode figurant dans sa liste d'appel. Les méthodes dupliquées sont appelées une fois pour chaque occurrence dans la liste d'appel. Les délégués sont immuables et par conséquent, une fois créée, la liste d'appel d'un délégué ne change pas.
Les délégués sont déclarés comme multicasts, ou comme pouvant être combinés, parce qu'un délégué peut appeler une ou plusieurs méthodes et être utilisé dans la combinaison d'opérations.
Les opérations d'association, comme Combine et Remove, ne modifient pas les délégués existants. En revanche, une telle opération retourne un nouveau délégué contenant le résultat de l'opération, un délégué inchangé ou référence Null (Nothing en Visual Basic). Une opération d'association retourne référence Null (Nothing en Visual Basic) si le résultat de l'opération est un délégué qui ne référence pas au moins une méthode. Elle retourne un délégué inchangé lorsque l'opération demandée n'a aucun effet.
Si une méthode appelée lève une exception, l'exécution de la méthode est interrompue, l'exception est passée à l'appelant du délégué et les autres méthodes 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é comporte 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 contient un paramètre passé par référence, la valeur finale du paramètre est le résultat obtenu une fois que chaque méthode de la liste d'appel s'est exécutée séquentiellement et qu'elle a mis à jour la valeur du paramètre.
Les compilateurs fournissent deux autres méthodes au délégué : BeginInvoke et EndInvoke. Pour plus d'informations sur ces méthodes, consultez Appel de méthodes synchrones de façon asynchrone.
En C ou C++, l'équivalent le plus proche d'un délégué est un pointeur 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, il 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 fonction, les délégués sont orientés objet et de type sécurisé.
ExempleL'exemple suivant montre comment définir un délégué standard.
Imports System 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 'mySampleClass Public Shared Sub Main() ' Creates one delegate for each method. 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 'Main End Class 'SamplesDelegate '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. 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 "". */
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. 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 "". */
import System.*; public class SamplesDelegate { /** @delegate */ // 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 static class MySampleClass { // Defines an instance method. public String MyStringMethod(int myInt) { if (myInt > 0) { return "positive"; } if (myInt < 0) { return "negative"; } return "zero"; } //myStringMethod // Defines a static method. public static String MySignMethod(int myInt) { if (myInt > 0) { return "+"; } if (myInt < 0) { return "-"; } return ""; } //MySignMethod } //MySampleClass public static void main(String[] args) { // Creates one delegate for each method. 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}\".", (Int32)(5), System.Convert.ToString(myD1.Invoke(5)), System.Convert.ToString(myD2.Invoke(5))); Console.WriteLine("{0} is {1}; use the sign \"{2}\".", System.Convert.ToString(-3), System.Convert.ToString(myD1.Invoke(-3)), System.Convert.ToString(myD2.Invoke(-3))); Console.WriteLine("{0} is {1}; use the sign \"{2}\".", (Int32)(0), System.Convert.ToString(myD1.Invoke(0)), System.Convert.ToString( myD2.Invoke(0))); } //main } //SamplesDelegate /* This code produces the following output: 5 is positive; use the sign "+". -3 is negative; use the sign "-". 0 is zero; use the sign "". */
Plates-formesWindows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition
Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.
Remarque
Outils (masquer)
S'enregistrer
Liste des Membres
Qui est en ligne?
FAQ