Informations supplémentaires sur les interfaces IObservable et IEnumerable dans StreamInsight

Cette rubrique contient des informations supplémentaires qui vous permettront de comprendre la prise en charge des sources et récepteurs d'événements observables et énumérables dans StreamInsight.

Prise en charge des interfaces IObservable et IObserver dans StreamInsight

Vue d'ensemble des interfaces IObservable et IObserver

L'interface IObservable fournit la méthode suivante :

Méthode	Description
Subscribe	Crée et retourne un abonnement qui implémente l'interface IObserver.

L'interface IObserver fournit les méthodes suivantes :

Méthode	Description
OnNext	Notifie l'observateur d'une nouvelle valeur dans la séquence.
OnError	Notifie l'observateur qu'une exception a eu lieu et que la séquence est terminée. Aucun appel à OnNext, OnCompleted ou OnError ne peut suivre cet appel.
OnCompleted	Notifie l'observateur de la fin de la séquence. Aucun appel à OnNext, OnCompleted ou OnError ne peut suivre cet appel.
Dispose	Supprime l'abonnement.

Entrée provenant d'une source d'événement IObservable

Lorsque vous démarrez une requête liée à une entrée observable, StreamInsight appelle la méthode IObservable.Subscribe de la source de l'événement, un abonnement est créé et la source de l'événement commence à fournir des données. L'entrée peut signaler une fin normale de ses données sources en appelant IObserver.OnCompleted. L'utilisateur peut aussi arrêter l'entrée en supprimant l'abonnement.

Exceptions et gestion des exceptions

Lorsque votre requête StreamInsight consomme une entrée observable, vous n'appelez pas les méthodes des interfaces IObservable ou IObserver dans le code que vous écrivez ; StreamInsight les appelle pour vous. Les informations suivantes vous aideront toutefois à comprendre quand des exceptions peuvent se produire et comment elles sont gérées.

L'adaptateur d'entrée conserve une référence à la source d'événement observable qui fournit les événements.

• Si un appel à IObservable.Subscribe lève une exception, celle-ci se propage au runtime StreamInsight et la requête est abandonnée.

• Si un appel à IObserver.Dispose lève une exception, celle-ci est journalisée et ignorée.

• Un appel à IObserver.OnCompleted provoque le signalement par l'adaptateur d'entrée de son arrêt. Les appels aux méthodes d'IObserver qui suivent cet appel sont traités comme des erreurs et peuvent lever des exceptions.

• Les exceptions qui se produisent lors d'appels à IObserver.OnNext entraînent l'abandon de la requête et la suppression de l'abonnement. Les appels aux méthodes d'IObserver qui suivent cet appel sont traités comme des erreurs et peuvent lever des exceptions. Une exception lors d'un appel à OnNext peut être provoquée par :

  • un événement Null ;

  • une violation CTI ;

  • une exception levée à partir d'une expression du sélecteur.

• Un appel à IObserver.OnNext se bloque lorsque le flux de l'adaptateur d'entrée est plein et qu'aucun événement ne peut être empilé.

• Un appel à IObserver OnError entraîne l'abandon de la requête. Les appels aux méthodes d'IObserver qui suivent cet appel sont traités comme des erreurs et peuvent lever des exceptions.

Sortie vers un récepteur d'événement IObservable

Lorsque l'observateur crée un abonnement en appelant la méthode Subscribe d'une sortie IObservable, une instance de requête est créée et démarrée, et la sortie temporaire commence à fournir des données. Une instance de requête existe pour chaque abonnement, et uniquement le temps de l'existence du consommateur. StreamInsight peut signaler la fin normale d'une requête en appelant IObserver.OnCompleted. L'utilisateur peut aussi arrêter et supprimer implicitement la requête en supprimant l'abonnement. À l'inverse, une requête temporaire n'est pas supprimée tant que l'abonnement correspondant ne l'est pas.

Exceptions et gestion des exceptions

Lorsque vous consommez la sortie d'une requête StreamInsight via les interfaces IObservable et IObserver, le code que vous écrivez dans le consommateur appelle directement les méthodes de ces interfaces. Les informations suivantes vous aideront à comprendre quand des exceptions peuvent se produire et comment elles sont gérées.

Lorsqu'un flux est converti en sortie IObservable, cette instance observable conserve une référence au flux d'origine. Les observateurs peuvent ensuite s'abonner pour recevoir des données.

• Un appel à IObservable.Subscribe entraîne la création et le démarrage d'une requête, ainsi que le début de la fourniture des événements à l'observateur. Subscribe peut lever une exception lorsque l'une des conditions suivantes est remplie :

  • Le serveur n'est pas un serveur incorporé.

  • La requête ne peut pas être créée.

  • La requête ne peut pas être démarrée.

• Un appel à IObserver.Dispose entraîne l'arrêt, puis la suppression de la requête. L'implémentation s'assure que les affirmations suivantes sont vraies :

  • Après le retour de l'appel à Dispose, aucun autre appel aux méthodes d'IObserver n'intervient.

  • La requête sous-jacente est arrêtée et supprimée dès que possible, mais pas nécessairement avant le retour de l'appel à Dispose.

  • Un appel à Dispose émanant d'une méthode d'IObserver ne provoque pas d'interblocage.

• IObserver.OnError est appelée lorsque la requête est abandonnée. L'implémentation fournit une exception qui contient au moins des informations textuelles relatives à l'échec. Après un appel à OnError, aucun autre appel aux méthodes d'IObserver n'intervient. OnError peut être appelée lorsque l'une des conditions suivantes est remplie :

  • Un adaptateur lève une exception.

  • Un opérateur lève une exception.

• IObserver.OnCompleted est appelée lorsque la requête a fini de traiter la sortie. Après un appel à OnCompleted, aucun autre appel aux méthodes d'IObserver n'intervient. OnCompleted peut être appelée lorsque l'une des conditions suivantes est remplie :

  • L'adaptateur de sortie reçoit un CTI égal à plus l'infini.

  • La requête est interrompue parce que tous les événements ont été consommés.

• Si des appels de StreamInsight à des méthodes d'IObserver (appels effectués dans le code utilisateur) lèvent une exception, la requête est abandonnée. Si la requête est déjà en cours d'abandon, cette exception est ignorée.

• Si une expression du sélecteur lève une exception, la requête est abandonnée.

Prise en charge de l'interface IEnumerable dans StreamInsight

Vue d'ensemble de l'interface IEnumerable

L'interface IEnumerable fournit la méthode suivante :

Méthode	Description
GetEnumerator	Crée et retourne un énumérateur qui implémente l'interface IEnumerator.

L'interface IEnumerator fournit les méthodes suivantes :

Méthode	Description
Current	Obtient l'élément actuel.
MoveNext	Avance l'énumérateur à l'élément suivant.
Reset	Rend à l'énumérateur sa position initiale, à savoir avant le premier élément. Aucun appel à d'autres méthodes d'IEnumerator ne peut suivre cet appel.
Dispose	Supprime l'énumérateur.

Entrée provenant d'une source d'événement IEnumerable

Lorsque vous démarrez une requête liée à une entrée temporaire, StreamInsight appelle la méthode IEnumerable.GetEnumerator de la source de l'événement et obtient un énumérateur. La source de l'événement commence ensuite à fournir des données en appelant IEnumerator.MoveNext et IEnumerator.Current dans une boucle, jusqu'à ce que le flux d'entrée soit vide. L'entrée peut signaler une fin normale de ses données sources en retournant la valeur False lorsque StreamInsight appelle MoveNext. L'utilisateur peut aussi arrêter l'entrée en supprimant l'énumérateur.

Exceptions et gestion des exceptions

Lorsque votre requête StreamInsight consomme une entrée énumérable, vous n'appelez pas les méthodes des interfaces IEnumerable ou IEnumerator dans le code que vous écrivez ; StreamInsight appelle pour vous les méthodes appropriées. Les informations suivantes vous aideront toutefois à comprendre quand des exceptions peuvent se produire et comment elles sont gérées.

L'adaptateur d'entrée conserve une référence à la source d'événement énumérable d'où sont extraits les événements. L'adaptateur d'entrée appelle la source de l'événement sur son propre thread pour obtenir des données.

• Si un appel à IEnumerable.GetEnumerator, IEnumerator.Current, IEnumerator.MoveNext ou à IEnumerator.Dispose lève une exception, la requête est abandonnée.

• Si une expression du sélecteur lève une exception, la requête est abandonnée.

Sortie vers un récepteur d'événement IEnumerable

Lorsque le consommateur obtient un énumérateur en appelant la méthode GetEnumerator d'une sortie IEnumerable, une instance de requête est créée et démarrée, et la sortie temporaire commence à fournir des données. Une instance de requête existe pour chaque énumérateur, et uniquement le temps de l'existence du consommateur. StreamInsight peut signaler la fin normale d'une requête en retournant la valeur False lorsque le consommateur appelle IEnumerator.MoveNext. L'utilisateur peut aussi arrêter et supprimer implicitement la requête en supprimant l'énumérateur. À l'inverse, une requête temporaire n'est pas supprimée tant que l'énumérateur correspondant ne l'est pas.

Exceptions et gestion des exceptions

Lorsque vous consommez la sortie d'une requête StreamInsight via les interfaces IEnumerable et IEnumerator, le code que vous écrivez dans le consommateur appelle directement les méthodes de ces interfaces. Les informations suivantes vous aideront à comprendre quand des exceptions peuvent se produire et comment elles sont gérées.

Lorsqu'un flux est converti en sortie IEnumerable, cette instance énumérable conserve une référence au flux d'origine. Les consommateurs appellent les méthodes d'IEnumerable et d'IEnumerator pour extraire des données.

• Un appel à IEnumerable.GetEnumerator entraîne la création d'une requête avec un adaptateur de sortie qui fournit des valeurs à la source externe. GetEnumerator peut lever une exception lorsque l'une des conditions suivantes est remplie :

  • Le serveur n'est pas un serveur incorporé.

  • La requête ne peut pas être créée.

  • La requête ne peut pas être démarrée (en raison, par exemple, de l'absence de certains adaptateurs).

• Un appel à IEnumerator.Dispose entraîne l'arrêt, puis la suppression de la requête. L'implémentation s'assure qu'après le retour de l'appel à Dispose, aucun autre appel aux méthodes d'IEnumerator n'intervient. Dispose peut lever une exception lorsque l'une des conditions suivantes est remplie :

  • La requête ne peut pas être arrêtée.

  • La requête ne peut pas être supprimée.

• Un appel à la méthode Current peut lever une exception si MoveNext n'a pas été appelée au moins une fois.

• Un appel à MoveNext :

  • ne lève aucune exception ;

  • retourne la valeur True tant qu'il existe des données à fournir ;

  • retourne la valeur False lorsque la requête s'est arrêtée ou a été abandonnée ;

  • se bloque lorsqu'il n'existe plus de données de sortie à fournir.