[Explication approfondie de C#] Chapitre 5 : Programmation avancée orientée objet : délégation et événements

News 2023-08-26 00:37:06 views: null

Les délégués et les événements sont des concepts importants dans la programmation orientée objet avancée, qui sont utilisés pour assurer la flexibilité, l'évolutivité et la maintenabilité du programme. Ils jouent un rôle clé dans la mise en œuvre des rappels, de la gestion des événements et de la programmation asynchrone, entre autres.
Les délégués nous permettent de traiter une méthode comme un objet qui peut être passé en paramètre, stocké dans une variable et appelé en cas de besoin. Cette capacité rend les délégués idéaux pour implémenter des fonctions de rappel, en passant d'une méthode à une autre afin que cette dernière appelle la première le cas échéant. La délégation prend également en charge le concept de chaîne de délégation et de délégation de multidiffusion, plusieurs méthodes peuvent être liées entre elles pour former une chaîne de délégation et elles sont exécutées en séquence.
Les événements sont une forme spéciale de délégation utilisée pour implémenter le modèle Observer et la programmation événementielle. Les événements constituent un moyen concis et fiable de gérer et de répondre à des événements de programme spécifiques, tels que l'interaction de l'utilisateur, la notification de message, etc. Grâce à l'événement, nous pouvons définir l'éditeur et l'abonné de l'événement. Lorsque l'éditeur déclenche l'événement, l'abonné recevra la notification et effectuera l'opération correspondante. Ce modèle de conception faiblement couplé rend le programme plus évolutif et plus maintenable.
Les délégués et les événements jouent également un rôle important dans la programmation asynchrone. Ils peuvent nous aider à gérer les rappels et les notifications pour les opérations asynchrones, améliorant ainsi la réactivité et l'efficacité des programmes. En encapsulant les opérations asynchrones dans des délégués ou des événements, nous pouvons exécuter la logique de traitement correspondante une fois les opérations asynchrones terminées sans bloquer le thread principal ni effectuer de gestion complexe des threads.

1. Le concept et l'utilisation de base du mandat

1.1 Définition et caractéristiques du mandat

Un délégué est un type de référence en C# qui nous permet de traiter des méthodes comme des objets et de transmettre des méthodes comme des paramètres, de les stocker dans des variables et de les appeler si nécessaire.
La définition d'un délégué comprend deux parties principales : la déclaration du type délégué et la création de l'instance du délégué. Une déclaration de type délégué spécifie la signature de la méthode, y compris les types de paramètres et le type de retour. Une instance de délégué est un objet créé selon le type de délégué, qui peut faire référence à une ou plusieurs méthodes. Les principales caractéristiques de la délégation sont les suivantes :

  1. Les délégués sont de type sécurisé : le type délégué définit la signature de la méthode, et seules les méthodes avec la même signature peuvent être affectées aux instances du type délégué.
  2. La délégation est composable : plusieurs méthodes peuvent être combinées via des chaînes de délégation pour former une chaîne de délégation. Chaque méthode de la chaîne de délégation peut être appelée tour à tour.
  3. Les délégués sont mutables : des méthodes peuvent être ajoutées ou supprimées dynamiquement de l'instance du délégué. Les méthodes peuvent être ajoutées à l'aide de l'opérateur "+" et supprimées à l'aide de l'opérateur "-".
  4. Le délégué est la base de la programmation asynchrone : le délégué peut être utilisé pour gérer la fonction de rappel de l'opération asynchrone, et le traitement correspondant est effectué en appelant l'instance du délégué une fois l'opération asynchrone terminée.

Les délégués jouent un rôle important dans la mise en œuvre des rappels, du traitement des événements et de la programmation multithread. Ils fournissent un moyen flexible, extensible et maintenable de gérer l'appel de méthode et la communication, rendant la programmation plus flexible et extensible.

1.2 Syntaxe et déclaration du délégué

La syntaxe et la déclaration du délégué comprennent principalement les étapes suivantes :

  1. Définition du type de délégué : utilisez delegatele mot-clé pour définir le type de délégué. Le type délégué définit la signature de la méthode, y compris les types de paramètres et le type de retour. Le format de syntaxe est le suivant :

    delegate <返回类型> <委托类型名>(<参数列表>);

    Par exemple, définissez un type délégué qui prend deux paramètres entiers et renvoie un entier :

    delegate int MyDelegate(int x, int y);

  2. Créer une instance de délégué : créez une instance de délégué en fonction du type de délégué et attribuez la méthode à l'instance de délégué. Les instances déléguées peuvent être créées à l'aide de méthodes anonymes, d'expressions lambda ou de méthodes nommées. Le format de syntaxe est le suivant :

    <委托类型> <委托实例名> = new <委托类型>(<方法名>);

    Par exemple, créez une instance de délégué et affectez-la à une méthode nommée :

    MyDelegate myDelegate = new MyDelegate(MyMethod);

  3. Appeler l’instance de délégué : utilisez l’instance de délégué pour appeler la méthode. Il peut être invoqué à l’aide de l’instance de délégué comme une méthode normale.

    int result = myDelegate(10, 20);

    Lors de l'appel d'une instance de délégué, le délégué appellera ces méthodes dans l'ordre des méthodes associées et renverra le résultat de la dernière méthode (s'il existe une valeur de retour).

Précautions:

  • La liste de paramètres et le type de retour d'un type délégué doivent correspondre à la signature de la méthode associée.
  • Une instance de délégué ne peut appeler que les méthodes qui correspondent au type de délégué. Une erreur de compilation se produira si l’instance du délégué appelle une méthode qui ne correspond pas.
  • Un type délégué est un type référence et une référence à une méthode peut être transmise via l’instance déléguée au lieu d’appeler directement la méthode.
  • Des méthodes peuvent être ajoutées et supprimées à l’aide des opérateurs +=et -=. +=L'opérateur ajoute une méthode à la chaîne de délégation et -=l'opérateur supprime une méthode de la chaîne de délégation.
1.3 Instanciation et invocation du délégué

L'instanciation et l'invocation du délégué impliquent principalement les étapes suivantes :

  1. Créer une instance de délégué : créez une instance de délégué en fonction du type de délégué et associez-la à une ou plusieurs méthodes. Les instances déléguées peuvent être créées à l'aide de méthodes anonymes, d'expressions lambda ou de méthodes nommées.

    <委托类型> <委托实例名> = new <委托类型>(<方法名>);

    Par exemple, créez une instance de délégué et associez-la à une méthode nommée :

    MyDelegate myDelegate = new MyDelegate(MyMethod);

  2. Appeler l'instance déléguée : invoquez la méthode associée via l'instance déléguée. Une instance de délégué peut être appelée comme une méthode normale, en passant des paramètres et en obtenant une valeur de retour.

    <返回值类型> result = <委托实例名>(<参数列表>);

    Par exemple, en utilisant une instance de délégué pour appeler une méthode associée :

    int result = myDelegate(10, 20);

    Notez que l'invocation de l'instance de délégué se déroulera dans l'ordre des méthodes de la chaîne de délégués, en appelant chaque méthode tour à tour et en renvoyant la valeur de retour de la dernière méthode (le cas échéant).

1.4 Chaîne de délégation et délégation multicast

Une chaîne de délégation est un mécanisme permettant de combiner plusieurs instances de délégation dans une chaîne logique. Une chaîne de délégation peut être créée en combinant une instance de délégation avec une autre instance de délégation.
Un délégué de multidiffusion est un type spécial de délégué qui peut contenir plusieurs instances de délégué, qui sont invoquées séquentiellement dans l'ordre dans lequel elles sont ajoutées. En utilisant la délégation de multidiffusion, les instances de délégué peuvent être ajoutées ou supprimées de la chaîne de délégués, étendant ou modifiant ainsi dynamiquement le comportement de la chaîne de délégués. En C#, vous pouvez utiliser +l'opérateur pour combiner plusieurs instances de délégué dans une chaîne de délégués et utiliser -l'opérateur pour supprimer l'instance de délégué de la chaîne de délégués.
Voici un exemple de code utilisant un délégué de multidiffusion :

public delegate void MyDelegate();

static void Main()
{
    
    
    MyDelegate myDelegate1 = Method1;
    MyDelegate myDelegate2 = Method2;

    // 创建委托链
    MyDelegate myDelegateChain = myDelegate1 + myDelegate2;

    // 调用委托链中的方法
    myDelegateChain();

    // 从委托链中移除委托实例
    myDelegateChain -= myDelegate2;

    // 再次调用委托链中的方法
    myDelegateChain();
}

static void Method1()
{
    
    
    Console.WriteLine("Method 1");
}

static void Method2()
{
    
    
    Console.WriteLine("Method 2");
}

Résultat de sortie :

Method 1
Method 2
Method 1

Dans l’exemple ci-dessus, myDelegate1et myDelegate2sont deux instances de délégué distinctes. En utilisant +l'opérateur pour les combiner dans une chaîne de délégation myDelegateChain, puis lorsque la chaîne de délégation est appelée, les méthodes des deux instances déléguées seront appelées tour à tour. Ensuite, utilisez -l'opérateur pour myDelegate2supprimer de la chaîne de délégation, et lors de l'appel à nouveau de la chaîne de délégation, seule myDelegate1la méthode de sera appelée.
Les délégués de multidiffusion offrent un moyen pratique et flexible de gérer plusieurs instances de délégué et d'exécuter leurs méthodes dans un ordre spécifique. C'est très utile dans des scénarios tels que la gestion d'événements, le mécanisme de rappel, etc.

2. Scénarios d'application commandés

2.1 Fonction de rappel

Un scénario d'application courant de délégation est la fonction de rappel (Callback). La fonction de rappel signifie que lorsqu'une opération est terminée ou qu'un événement se produit, le système appelle une fonction pré-enregistrée pour traiter la logique correspondante. Grâce au mécanisme de délégation, une fonction peut être passée en paramètre à une autre fonction, afin que cette dernière puisse appeler la fonction entrante au moment opportun. Ce mécanisme est utile dans les situations où des opérations asynchrones, la gestion des événements, l'interaction de l'utilisateur, etc. sont requises. Voici un exemple de code qui implémente une fonction de rappel à l'aide de délégués :

public delegate void CallbackFunction(string message);

public class Operation
{
    
    
    public void LongRunningOperation(CallbackFunction callback)
    {
    
    
        // 模拟耗时操作
        Console.WriteLine("开始执行长时间操作...");
        Thread.Sleep(2000);
        Console.WriteLine("长时间操作完成。");

        // 调用回调函数
        callback("操作已完成");
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Operation operation = new Operation();
        operation.LongRunningOperation(OnOperationComplete);
    }

    static void OnOperationComplete(string message)
    {
    
    
        Console.WriteLine("操作回调：" + message);
    }
}

Résultat de sortie :

开始执行长时间操作...
长时间操作完成。
操作回调：操作已完成

Dans l'exemple ci-dessus, la méthode Operationde la classe LongRunningOperationeffectue une opération fastidieuse, puis CallbackFunctionappelle la fonction de rappel via le paramètre de type délégué transmis. ProgramLa méthode de la classe OnOperationCompleteagit comme une fonction de rappel appelée et génère un message lorsque l'opération est terminée.
En utilisant des délégués et des fonctions de rappel, l'appelant peut être informé du résultat ou de l'état de l'opération, et la logique correspondante peut être exécutée à un moment approprié, réalisant ainsi un contrôle et une interaction plus flexibles du programme. Les fonctions de rappel sont souvent utilisées dans des scénarios tels que la programmation asynchrone, la programmation événementielle et l'interaction avec l'interface utilisateur.

2.2 Traitement des événements

Les délégués sont largement utilisés dans la gestion des événements. Un événement fait référence à une action spécifique ou à un changement d'état qui se produit dans un programme, et le traitement des événements est un mécanisme permettant de répondre et de traiter ces événements. Grâce à la combinaison de la délégation et des événements, un modèle de conception faiblement couplé peut être réalisé, c'est-à-dire une programmation événementielle. Dans la programmation événementielle, les objets communiquent en définissant des événements et les délégués correspondants. Lorsqu'un événement se produit, la méthode enregistrée auprès du délégué correspondant sera appelée pour répondre à l'événement. Voici un exemple de code pour la gestion des événements à l'aide de délégués et d'événements :

public class Button
{
    
    
    public event EventHandler Click;

    public void OnClick()
    {
    
    
        // 触发 Click 事件
        Click?.Invoke(this, EventArgs.Empty);
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Button button = new Button();
        button.Click += Button_Click;

        button.OnClick();
    }

    static void Button_Click(object sender, EventArgs e)
    {
    
    
        Console.WriteLine("按钮被点击了！");
    }
}

Résultat de sortie :

按钮被点击了！

Dans l'exemple ci-dessus, Buttonla classe définit un Clickévénement nommé et utilise EventHandlerle délégué comme type de gestionnaire d'événement. ButtonLa méthode de la classe OnClickest utilisée pour déclencher Clickl'événement et Click?.Invoke(this, EventArgs.Empty)appeler le gestionnaire d'événements enregistré via . Dans Programla classe, nous instancions un Buttonobjet et enregistrons la méthode en tant que gestionnaire d'événements +=via l'opérateur . Ensuite, l'événement click du bouton est déclenché par un appel et la méthode de gestionnaire d'événements correspondante est exécutée. En utilisant des délégués et des événements, nous pouvons facilement dissocier les événements du traitement des événements, rendant ainsi l'interaction des objets plus flexible et extensible. Les modèles de programmation basés sur les événements sont largement utilisés dans les interfaces utilisateur graphiques (GUI), les interactions utilisateur, la programmation asynchrone et d'autres scénarios.Button_ClickClickbutton.OnClick()

2.3 Programmation asynchrone

Delegate joue un rôle important dans la programmation asynchrone, il peut aider à gérer des opérations chronophages et à améliorer les performances et la réactivité des applications. Dans le modèle de programmation synchrone traditionnel, lorsqu'un programme effectue une opération fastidieuse, il bloque le thread principal, rendant l'application insensible. Le modèle de programmation asynchrone implémente des opérations asynchrones à l'aide de délégués, afin que le thread principal puisse continuer à effectuer d'autres tâches sans attendre la fin d'opérations fastidieuses. Voici un exemple de code pour la programmation asynchrone utilisant des délégués :

public class Worker
{
    
    
    public delegate void WorkCompletedHandler(string result);

    public void DoWorkAsync(WorkCompletedHandler callback)
    {
    
    
        // 模拟耗时操作
        Console.WriteLine("开始执行异步操作...");
        Thread.Sleep(2000);
        string result = "操作已完成";

        // 异步操作完成后调用回调函数
        callback(result);
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Worker worker = new Worker();
        worker.DoWorkAsync(OnWorkCompleted);

        Console.WriteLine("主线程继续执行其他任务...");
        // 等待异步操作完成
        Console.ReadLine();
    }

    static void OnWorkCompleted(string result)
    {
    
    
        Console.WriteLine("异步操作回调：" + result);
    }
}

Résultat de sortie :

开始执行异步操作...
主线程继续执行其他任务...
异步操作回调：操作已完成

Dans l'exemple ci-dessus, la méthode Workerde la classe DoWorkAsyncsimule une opération asynchrone fastidieuse et WorkCompletedHandlerappelle la fonction de rappel une fois l'opération terminée via le paramètre de type délégué entrant. Dans Programla classe, nous instancions un Workerobjet et appelons DoWorkAsyncla méthode, en la transmettant OnWorkCompletedcomme fonction de rappel. Dans le thread principal, nous pouvons continuer à effectuer d'autres tâches sans attendre la fin de l'opération asynchrone.
La programmation asynchrone peut améliorer les performances et la réactivité des applications grâce au mécanisme de délégation et de fonctions de rappel. Il est largement utilisé dans les scénarios qui doivent effectuer des opérations fastidieuses, éviter le blocage du thread principal et les traitements simultanés.

3. Le concept et l'utilisation de base des événements

3.1 Définition et caractéristiques des événements

Les événements sont un mécanisme de programmation orientée objet permettant de gérer des actions spécifiques ou des changements d'état qui se produisent sur des objets. Les événements peuvent être considérés comme un type spécial de délégué qui fournit aux objets un moyen de communication faiblement couplé en définissant et en déclenchant des événements.
Les événements ont les caractéristiques suivantes :

  1. Modèle d'éditeur et d'abonné : les événements ont généralement un objet en tant qu'éditeur qui déclenche l'événement lorsque certaines conditions sont remplies. D'autres objets peuvent s'abonner à l'événement et fournir une logique de traitement correspondante pour répondre à l'occurrence de l'événement.
  2. Délégués en tant que types de gestionnaires d'événements : les événements utilisent souvent des types de délégués pour définir des gestionnaires d'événements. Un délégué est un type utilisé pour faire référence à une méthode, qui peut être passée en paramètre et invoquée lorsqu'un événement se produit.
  3. Enregistrement et désenregistrement des gestionnaires d'événements : les objets abonnés à des événements peuvent utiliser +=l'opérateur pour enregistrer leurs propres méthodes en tant que gestionnaires d'événements. Lorsqu'un événement se produit, le gestionnaire d'événements enregistré sera appelé. En utilisant -=l'opérateur, un gestionnaire d'événements peut être désenregistré pour ne plus recevoir de notifications d'événements.
  4. Prise en charge de plusieurs gestionnaires d'événements : les événements peuvent prendre en charge plusieurs gestionnaires d'événements, c'est-à-dire que plusieurs méthodes peuvent s'abonner au même événement en même temps. Lorsqu'un événement se produit, tous les gestionnaires d'événements abonnés seront appelés.
  5. Conception faiblement couplée : le mécanisme d'événement réalise un couplage lâche entre les objets, et l'objet éditeur n'a pas besoin de comprendre et dépend directement de l'implémentation spécifique de l'objet abonné. Les éditeurs doivent uniquement déclencher des événements et les abonnés décident comment gérer les événements.
3.2 Syntaxe et déclaration des événements

En C#, la syntaxe de déclaration et d'utilisation des événements est la suivante :

  1. Définir des événements :
    public event EventHandler MyEvent;
    Le code précédent définit un MyEventévénement nommé de type EventHandler. EventHandlerEst un type de délégué prédéfini, généralement utilisé pour gérer des événements sans paramètres.
  2. Déclarez les gestionnaires d'événements :
    private void OnMyEvent(object sender, EventArgs e)
{
    // 处理事件的逻辑代码
}
    Le code ci-dessus déclare une OnMyEventméthode de gestionnaire d'événements nommée , qui accepte deux paramètres : senderl'objet éditeur représentant l'événement eet les paramètres de l'événement. En fonction des besoins réels, vous pouvez personnaliser le nom et les paramètres de la méthode du gestionnaire d'événements.
  3. Enregistrez les gestionnaires d'événements :
    MyEvent += OnMyEvent;
    Le code précédent OnMyEventenregistre la méthode en tant que MyEventgestionnaire de l'événement. La méthode sera appelée lorsque MyEventl'événement se déclenchera .OnMyEvent
  4. Désinscrire les gestionnaires d'événements :
    MyEvent -= OnMyEvent;
    Le code ci-dessus désenregistre OnMyEventla méthode de MyEventla liste des gestionnaires de l'événement et cesse de recevoir des notifications d'événement.

Veuillez noter que le code ci-dessus n'est qu'un exemple, vous pouvez l'ajuster et l'étendre en fonction de vos besoins et scénarios réels. Dans le même temps, vous pouvez également définir des types de paramètres d'événement personnalisés selon vos besoins pour transmettre davantage d'informations que le processeur d'événements pourra utiliser.

3.3 Souscription et déclenchement des événements

En C#, le processus d'abonnement et de déclenchement d'événements est le suivant :

  1. Définir des événements :

    public event EventHandler MyEvent;

    Définissez un MyEventévénement nommé , en utilisant EventHandlerle type de délégué comme type d'événement.

  2. Définissez les gestionnaires d'événements :

    private void OnMyEvent(object sender, EventArgs e)
{
    // 处理事件的逻辑代码
}

    Définissez une OnMyEventméthode nommée gestionnaire d'événements, qui accepte deux paramètres : senderl'objet éditeur représentant l'événement eet le paramètre d'événement.

  3. Abonnez-vous aux événements :

    MyEvent += OnMyEvent;

    La méthode du gestionnaire d'événements est abonnée à l'événement à l'aide +=de l'opérateur . De cette façon, lorsque l'événement se déclenche, la méthode du gestionnaire d'événements sera appelée.OnMyEventMyEventMyEvent

  4. événement déclencheur:

    MyEvent?.Invoke(this, EventArgs.Empty);

    ?.InvokeLes événements sont déclenchés en utilisant la syntaxe MyEvent. Cela appelle à son tour toutes les méthodes de gestionnaire d'événements abonnés à l'événement. Paramètre thisIndique l'objet éditeur de l'événement et EventArgs.Emptyindique les paramètres de l'événement, et un objet paramètre vide est utilisé ici.

  5. Se désabonner des événements :

    MyEvent -= OnMyEvent;

    Utilisez -=l'opérateur pour désabonner une méthode de gestionnaire d'événements OnMyEventde la liste d'abonnement de l'événement . MyEventDe cette façon, lorsque MyEventl'événement se déclenche, la méthode du gestionnaire d'événements ne sera plus appelée.

Les étapes ci-dessus constituent les étapes de base de l'abonnement et du déclenchement d'événements, que vous pouvez ajuster et développer en fonction des besoins et des scénarios réels. Veuillez noter que la souscription et le déclenchement des événements doivent être effectués au bon moment pour garantir le bon processus de gestion des événements.

4. Scénarios d'application des événements

4.1 Interaction utilisateur dans les applications GUI

Dans les applications GUI (Graphical User Interface), les événements jouent un rôle important dans la gestion des interactions utilisateur. Voici quelques scénarios d'application courants d'événements dans les applications GUI :

  1. Événement de clic de bouton : un événement déclenché lorsque l'utilisateur clique sur un bouton de l'interface et les opérations associées peuvent être effectuées dans le gestionnaire d'événements, telles que la soumission d'un formulaire, l'ouverture d'une nouvelle fenêtre, etc.
  2. Événement de saisie dans la zone de texte : un événement déclenché lorsque l'utilisateur saisit du contenu dans la zone de texte. Le texte saisi peut être obtenu via le gestionnaire d'événements et traité en conséquence, comme la vérification des saisies, la recherche en temps réel, etc.
  3. Événement de sélection de menu : événement déclenché lorsque l'utilisateur sélectionne une option dans le menu et que les opérations correspondantes peuvent être effectuées dans le gestionnaire d'événements, telles que l'ouverture d'une page de fonction spécifique, l'exécution d'une commande spécifique, etc.
  4. Événements de mouvement et de clic de la souris : les événements déclenchés lorsque l'utilisateur déplace la souris sur l'interface ou clique sur un élément spécifique peuvent répondre aux opérations de la souris selon la logique du gestionnaire d'événements, comme l'affichage d'informations d'invite, le déplacement d'éléments, etc.
  5. Événement de fermeture de fenêtre : l'événement déclenché lorsque l'utilisateur ferme la fenêtre, vous pouvez effectuer des opérations associées dans le gestionnaire d'événements, telles que la sauvegarde des données, le nettoyage des ressources, etc.

Grâce à l'utilisation d'événements, les applications GUI peuvent interagir et réagir avec les utilisateurs, offrant ainsi une expérience utilisateur plus conviviale et plus flexible. Les développeurs peuvent implémenter diverses logiques et fonctions d'interaction utilisateur en s'abonnant et en traitant les événements correspondants.

4.2 Notification de message et événementiel

Les événements ont un large éventail de scénarios d'application dans la notification de messages et la programmation événementielle. Voici des cas d'utilisation courants pour les événements dans ces domaines :

  1. Notification de message : les événements peuvent être utilisés pour mettre en œuvre un mécanisme de notification de message. Lorsqu'un événement se produit, le système peut déclencher l'événement correspondant et avertir les autres modules ou objets abonnés à l'événement. Cela peut réaliser le découplage et la livraison de messages entre les modules.
  2. Modèle de publication-abonnement : les événements peuvent être utilisés pour implémenter un modèle de publication-abonnement, dans lequel un objet (éditeur) déclenche un événement et d'autres objets (abonnés) s'abonnent à l'événement et répondent à la logique de traitement correspondante. Ce modèle est très courant dans des scénarios tels que les systèmes distribués et les files d'attente de messages.
  3. Interaction utilisateur dans les applications GUI : dans les applications d'interface utilisateur graphique (GUI), la programmation événementielle est un modèle courant. Lorsque l'utilisateur interagit avec l'interface, des événements sont utilisés pour déclencher les opérations de réponse correspondantes. Par exemple, cliquer sur un bouton, faire glisser un élément, saisir au clavier, etc. peuvent déclencher les événements correspondants pour le traitement.
  4. Programmation asynchrone : les événements peuvent être utilisés pour implémenter un modèle de programmation asynchrone, dans lequel un événement est déclenché lorsqu'une opération est terminée pour informer les autres parties à traiter. Ceci est utile lorsque vous traitez de grandes quantités de données, des tâches de longue durée ou lorsqu'une interaction avec des ressources externes est requise.
  5. Extension des frameworks et des bibliothèques : en définissant et en utilisant des événements, les développeurs peuvent fournir des points d'extension pour les frameworks et les bibliothèques, permettant à d'autres développeurs d'enregistrer une logique personnalisée sur des événements spécifiques, réalisant ainsi des extensions de fonctions personnalisées et flexibles.

Grâce à l'utilisation d'événements, un couplage lâche entre les modules, une évolutivité flexible et une gestion des opérations asynchrones peuvent être obtenus. Il s'agit d'un mécanisme puissant qui permet aux différentes parties d'un programme de fonctionner ensemble efficacement et d'interagir de manière à répondre aux événements.

5. Comparaison et sélection des délégués et des événements

5.1 La différence entre délégué et événement

Les délégués et les événements sont deux concepts importants dans la programmation orientée objet, qui sont utilisés pour implémenter la transmission et le traitement des messages entre les objets. Bien qu’ils soient similaires à certains égards, il existe certaines différences dans leurs définitions, utilisations et objectifs.

  1. Définition et syntaxe :
    • Un délégué est un type qui encapsule une référence à une méthode. Il définit la signature de la méthode et le type de retour, et peut être utilisé pour déclarer des variables, des paramètres et des types de retour.
    • Les événements sont un type spécial de délégué utilisé pour définir et déclencher des actions spécifiques. Les événements sont eventdéclarés à l'aide du mot-clé et ne peuvent être définis que dans des classes ou des structures.
  2. Rôle et objectif :
    • Les délégués sont utilisés pour transmettre des références aux méthodes, ce qui permet de transmettre des méthodes en tant que paramètres à d'autres méthodes ou de les stocker dans des variables. Les délégués sont souvent utilisés dans des scénarios tels que les fonctions de rappel, le traitement des événements et la programmation asynchrone.
    • Les événements sont un type spécial de délégué utilisé pour définir et déclencher des actions ou des notifications spécifiques. Il permet à une classe ou à une structure de notifier d'autres objets lorsqu'un événement spécifique se produit et d'exécuter le gestionnaire d'événements correspondant.
  3. Abonnez-vous et déclenchez :
    • Un délégué peut +=s'abonner à plusieurs méthodes à l'aide de l'opérateur, afin que plusieurs méthodes puissent répondre à l'appel du délégué. Lorsque le délégué est appelé, les méthodes souscrites seront invoquées dans l'ordre.
    • Un événement est une forme spéciale de délégation, qui ne peut être déclenchée qu'à l'intérieur de la classe, et les objets externes ne peuvent répondre à l'occurrence d'événements qu'en s'abonnant à l'événement.
  4. Sécurité et encapsulation :
    • Les événements ont une sécurité et une encapsulation plus élevées, car les événements ne peuvent être déclenchés qu'à l'intérieur de la classe et les objets externes ne peuvent pas appeler ou modifier directement le déclenchement des événements.
    • Un délégué est relativement plus flexible à utiliser car il peut être stocké dans une variable et permet à des objets externes d'appeler directement le délégué.
5.2 Sélectionnez le délégué et l'événement appropriés

Lors du choix des délégués et des événements appropriés, des scénarios d'application et des exigences spécifiques doivent être pris en compte. Voici quelques suggestions:

  1. commandé:
    • Utilisez des délégués pour transmettre des références de méthode afin de répondre à des exigences telles que les fonctions de rappel ou la programmation asynchrone.
    • Si vous devez transmettre des méthodes entre différents objets et que vous souhaitez que ces objets puissent effectuer des appels de méthode indépendamment, vous pouvez choisir d'utiliser la délégation.
  2. événement:
    • Utilisez des événements pour définir et déclencher des actions ou des notifications spécifiques afin de réaliser le découplage et la transmission de messages entre les objets.
    • Si vous devez déclencher une action spécifique au sein de la classe et souhaitez que d'autres objets s'abonnent et répondent à cette action, vous pouvez choisir d'utiliser des événements.
  3. Pensez à la sécurité et à l'encapsulation :
    • Si vous souhaitez limiter le déclenchement et le fonctionnement d'événements par des objets externes et protéger l'état interne de la classe, vous pouvez choisir d'utiliser des événements.
    • Si vous avez besoin de transmettre de manière flexible la référence de la méthode et que vous souhaitez que l'objet externe appelle directement le délégué, vous pouvez choisir d'utiliser le délégué.
  4. Pensez à l’évolutivité et à la réutilisabilité :
    • Vous pouvez choisir d'utiliser des événements lorsque vous souhaitez pouvoir partager la même définition d'événement entre plusieurs classes et permettre à chaque classe d'ajouter et de répondre indépendamment aux gestionnaires d'événements.
    • Si vous souhaitez pouvoir réutiliser le même type de délégué à plusieurs endroits et ne pas vous limiter aux événements internes d'une classe spécifique, vous pouvez choisir d'utiliser des délégués.

En bref, les délégués conviennent à des scénarios tels que la transmission de références de méthodes, l'implémentation de fonctions de rappel et la programmation asynchrone, tandis que les événements conviennent à la définition et au déclenchement d'actions ou de notifications spécifiques et à la réalisation du découplage entre les objets. Selon les exigences de l'application, choisissez le mécanisme le plus approprié pour réaliser la fonction et répondre aux exigences.

6. Meilleures pratiques et précautions pour la mise en service et les événements

Voici quelques bonnes pratiques et considérations lors de l’utilisation de délégués et d’événements :

  1. Dénomination des délégués et des événements : la dénomination doit refléter avec précision leur objectif et leur fonction, et suivre les conventions de dénomination pour améliorer la lisibilité du code.
  2. Gestion du cycle de vie déléguée : lorsque vous utilisez des délégués, vous devez vous assurer que le cycle de vie délégué est géré correctement pour éviter d'éventuelles fuites de mémoire. Utilisez les méthodes appropriées pour ajouter et supprimer des abonnements délégués.
  3. Calendrier de déclenchement des événements : lors de la conception et de la mise en œuvre d'événements, vous devez prendre en compte le moment de déclenchement des événements pour garantir que les événements sont déclenchés à un moment approprié pour répondre aux exigences et aux fonctions.
  4. Sécurité des gestionnaires d'événements : lorsque d'autres objets s'abonnent et répondent aux événements, la sécurité des gestionnaires d'événements doit être assurée pour gérer les exceptions possibles et les conditions d'erreur afin de garantir la stabilité du programme.
  5. Documentation des délégués et des événements : fournissez une documentation claire dans le code pour expliquer le but, l'utilisation et le comportement attendu des délégués et des événements afin d'aider les autres développeurs à les comprendre et à les utiliser.
  6. Applicabilité des délégués et des événements : lors du choix de recourir à des délégués et des événements, des besoins et des scénarios spécifiques doivent être pris en compte pour garantir leur applicabilité et leur rationalité. N'abusez pas des délégués et des événements, mais choisissez le mécanisme de programmation approprié en fonction de la situation réelle.
  7. Clarté et maintenabilité du code : lorsque vous utilisez des délégués et des événements, conservez la clarté et la maintenabilité du code, et suivez un bon style de codage et des principes de conception pour améliorer la lisibilité et la maintenabilité du code.

7. Résumé

Les délégués et les événements sont des concepts importants dans la programmation orientée objet, ils offrent flexibilité et extensibilité, nous permettant d'obtenir un code découplé et réutilisable. Les délégués nous permettent de transmettre et de stocker des méthodes en tant que paramètres et de les appeler en cas de besoin, ce qui est très utile pour implémenter des fonctions de rappel et la programmation asynchrone. Les événements sont une forme spéciale de délégation qui gère des actions spécifiques ou déclenche des conditions spécifiques. Les événements fournissent un moyen faiblement couplé de notifier et de répondre aux interactions entre les objets.
Lorsque nous utilisons des délégués et des événements, nous devons suivre les meilleures pratiques et considérations, telles qu'une dénomination précise, une gestion correcte du cycle de vie, le déclenchement rapide des événements, la gestion de la sécurité et des exceptions, la fourniture d'une documentation claire, etc. Le choix du délégué et de l'événement approprié dépend des besoins et des scénarios spécifiques et garantit son applicabilité et sa rationalité. Il est très important de garder le code clair et maintenable. Un bon style de codage et des principes de conception peuvent améliorer la lisibilité et la maintenabilité du code.

Je suppose que tu aimes

Origine blog.csdn.net/gangzhucoll/article/details/131750446
conseillé
Classement
du quotidien
Plus
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)

Code World

© 2018 codetd.com