Exploration des principales interfaces dans Rx

Cette rubrique décrit les principales interfaces Rx (Reactive Extensions) utilisées pour représenter des séquences observables et s’y abonner.

Les interfaces T>/IObserver<<T> sont disponibles dans la bibliothèque de classes de base .NET Framework 4.0, et elles sont fournies dans un package qui peut être installé dans .NET 3.5, Silverlight 3 et 4, ainsi que Javascript.

IObservable<T>/IObserver<T>

Rx expose des sources de données asynchrones et basées sur des événements sous forme de séquences observables basées sur push, abstraites par la nouvelle interface T> IObservable<dans .NET Framework 4.0. Cette interface T IObservable<est un double de l’interface IEnumerable<T> familière utilisée pour les collections basées sur l’extraction et énumérables.> Il représente une source de données qui peut être observée, ce qui signifie qu’elle peut envoyer des données à quiconque est intéressé. Il gère une liste d’implémentations IObserver<T> dépendantes représentant ces écouteurs intéressés et les avertit automatiquement de toute modification d’état.

Une implémentation de l’interface T> IObservable<peut être vue comme une collection d’éléments de type T. Par conséquent, un int> IObservable<peut être vu comme une collection d’entiers, dans lequel les entiers sont envoyés aux observateurs abonnés.

Comme décrit dans Qu’est-ce que Rx, l’autre moitié du modèle push est représentée par l’interface IObserver<T> , qui représente un observateur qui inscrit un intérêt via un abonnement. Les éléments sont ensuite remis à l’observateur à partir de la séquence observable à laquelle il s’abonne.

Pour recevoir des notifications d’une collection observable, vous utilisez la méthode Subscribe de IObservable pour lui remettre un objet T> IObserver<. En retour de cet observateur, la méthode Subscribe retourne un objet IDisposable qui fait office de handle pour l’abonnement. Cela vous permet de propre l’abonnement une fois que vous avez terminé.  L’appel de Disposition sur cet objet détache l’observateur de la source afin que les notifications ne soient plus remises. Comme vous pouvez le déduire, dans Rx, vous n’avez pas besoin de vous désabonner explicitement d’un événement comme dans le modèle d’événement .NET.

Les observateurs prennent en charge trois événements de publication, reflétés par les méthodes de l’interface. OnNext peut être appelé zéro ou plusieurs fois, lorsque la source de données observable a des données disponibles. Par exemple, une source de données observable utilisée pour les événements de déplacement de souris peut envoyer un objet Point à chaque déplacement de la souris. Les deux autres méthodes sont utilisées pour indiquer l’achèvement ou les erreurs.

L’exemple suivant répertorie les interfaces T>/IObservable<<T>.

public interface IObservable<out T> 
{ 
   IDisposable Subscribe(IObserver<T> observer); 
} 
public interface IObserver<in T> 
{ 
   void OnCompleted();            // Notifies the observer that the source has finished sending messages.
   void OnError(Exception error); // Notifies the observer about any exception or error.
   void OnNext(T value);          // Pushes the next data value from the source to the observer.
} 

Rx fournit également des méthodes d’extension Subscribe afin que vous puissiez éviter d’implémenter l’interface T IObserver<vous-même> . Pour chaque événement de publication (OnNext, OnError, OnCompleted) d’une séquence observable, vous pouvez spécifier un délégué qui sera appelé, comme illustré dans l’exemple suivant. Si vous ne spécifiez pas d’action pour un événement, le comportement par défaut se produit.

IObservable<int> source = Observable.Range(1, 5); //creates an observable sequence of 5 integers, starting from 1
IDisposable subscription = source.Subscribe(
                            x => Console.WriteLine("OnNext: {0}", x), //prints out the value being pushed
                            ex => Console.WriteLine("OnError: {0}", ex.Message),
                            () => Console.WriteLine("OnCompleted"));

Vous pouvez traiter la séquence observable (par exemple, une séquence d’événements de survol de la souris) comme s’il s’agissait d’une collection normale. Ainsi, vous pouvez écrire des requêtes LINQ sur la collection pour effectuer des opérations telles que le filtrage, le regroupement, la composition, etc. Pour rendre les séquences observables plus utiles, les assemblys Rx fournissent de nombreux opérateurs LINQ d’usine afin que vous n’ayez pas besoin d’implémenter ces séquences par vous-même. Cela sera abordé dans la rubrique Interrogation des séquences observables à l’aide d’opérateurs LINQ .

Voir aussi

Concepts

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

Autres ressources

Création et interrogation de séquences observables