Pontage avec les événements .NET existants

Rx fournit des méthodes d’usine pour vous permettre d’établir un pont avec des sources asynchrones existantes dans .NET afin que vous puissiez utiliser les fonctionnalités de composition, de filtrage et de gestion des ressources enrichies fournies par Rx sur n’importe quel type de flux de données. Cette rubrique examine l’opérateur FromEventPattern qui permet « d’importer » un événement .NET dans Rx en tant que séquence observable. Chaque fois qu’un événement est déclenché, un message OnNext est remis à la séquence observable. Vous pouvez ensuite manipuler des données d’événement comme n’importe quelle séquence observable.

Rx ne vise pas à remplacer les modèles de programmation asynchrone existants tels que les événements .NET, le modèle asynchrone ou la bibliothèque parallèle de tâches. Toutefois, lorsque vous tentez de composer des événements, les méthodes d’usine de Rx vous offrent la commodité qui est introuvable dans le modèle de programmation actuel. Cela est particulièrement vrai pour la maintenance des ressources (par exemple, quand se désabonner) et le filtrage (par exemple, le choix du type de données à recevoir). Dans cette rubrique et celles qui suivent, vous pouvez examiner comment ces fonctionnalités Rx peuvent vous aider dans la programmation asynchrone.

Conversion d’un événement .NET en séquence observable rx

L’exemple suivant crée un gestionnaire d’événements .NET simple pour l’événement de déplacement de la souris et imprime l’emplacement de la souris dans une étiquette dans un formulaire Windows.

using System.Linq;
using System.Windows.Forms;
using System.Reactive;
using System.Reactive.Linq;
using System;
using WinForm;
using System.Reactive.Disposables;

class Program {
 
    static void Main() 
    {
         var lbl = new Label(); 
         var frm = new Form { Controls = { lbl } }; 
         frm.MouseMove += (sender, args) =>
         {
              lbl.Text = args.Location.ToString();
         };
         Application.Run(frm);
    }; 
}

Pour importer un événement dans Rx, vous pouvez utiliser l’opérateur FromEventPattern et fournir les objets EventArgs qui seront déclenchés par l’événement en cours de pont. L’opérateur FromEventPattern fonctionne avec les événements qui prennent un expéditeur d’objet et certains EventArgs, et utilise la réflexion pour rechercher ces méthodes d’ajout/suppression pour vous. Il convertit ensuite l’événement donné en séquence observable avec un type EventPattern qui capture à la fois l’expéditeur et les arguments d’événement.

Pour les délégués qui ont un paramètre (événements non standard), vous pouvez utiliser l’opérateur FromEvent qui prend une paire de fonctions utilisées pour attacher et détacher un gestionnaire.

Dans l’exemple suivant, nous convertissons le flux d’événements de déplacement de la souris d’un formulaire Windows en séquence observable. Chaque fois qu’un événement de déplacement de souris est déclenché, l’abonné reçoit une notification OnNext. Nous pouvons ensuite examiner la valeur EventArgs de cette notification et obtenir l’emplacement du déplacement de la souris.

using System.Linq;
using System.Windows.Forms;
using System.Reactive;
using System.Reactive.Linq;
using System;
using WinForm;
using System.Reactive.Disposables;

class Program {
 
    static void Main() 
    {
         var lbl = new Label(); 
         var frm = new Form { Controls = { lbl } }; 
         IObservable<EventPattern<MouseEventArgs>> move = Observable.FromEventPattern<MouseEventArgs>(frm, "MouseMove");
         move.Subscribe(evt => { 
                             lbl.Text = evt.EventArgs.Location.ToString(); 
                       }) ;
         Application.Run(frm);
   }; 
}

Notez que dans cet exemple, move devient une séquence observable dans laquelle nous pouvons manipuler davantage. La rubrique Interrogation de séquences observables à l’aide d’opérateurs LINQ vous montre comment projeter cette séquence dans une collection de type Points et filtrer son contenu, afin que votre application ne reçoive que des valeurs qui répondent à certains critères.

Le nettoyage du gestionnaire d’événements est pris en charge par l’objet IDisposable retourné par la méthode Subscribe. L’appel de Disposition (effectué en atteignant la fin du bloc using dans cet exemple) libère toutes les ressources utilisées par la séquence, y compris le gestionnaire d’événements sous-jacent. Cela prend essentiellement en charge la désinscripion d’un événement en votre nom.

Voir aussi

Concepts

Interrogation de séquences observables à l’aide d’opérateurs LINQ