Utilisation des sources et récepteurs d'événements observables et énumérables (StreamInsight)

  • Article

StreamInsight prend en charge les sources et récepteurs d'événements qui implémentent les interfaces IObservable et IEnumerable. Ces interfaces servent la majorité des contrats à usage général du .NET Framework pour l'extraction (IEnumerable) et la transmission (IObservable) de données parmi les composants d'une application.

Si les interfaces IEnumerable et IEnumerator sont déjà connues des développeurs .NET, les interfaces IObservable et IObserver ont été introduites plus récemment, dans .NET Framework 4. Le modèle de développement d'IObservable se base sur le modèle de conception observable/observateur. Dans ce modèle de conception :

  • un observateur est tout objet voulant être notifié lorsque l'état d'un autre objet change ;

  • un observable est une séquence de transmission pour laquelle un autre objet peut manifester de l'intérêt.

Dans une application StreamInsight, l'observable est la source de l'événement. La requête agit comme observateur de cette source et présente son résultat comme un observable dans le récepteur de l'événement, qui à son tour devient observateur de la requête en tant que source. Pour plus d'informations, voir l'article relatif à l'exploration d'un modèle de conception d'observateur sur MSDN.

Les tâches que doit réaliser le développeur de l'application pour activer ce modèle de développement sont minimales :

  1. Fournir une classe qui implémente l'interface IObservable ou IEnumerable en tant que producteur d'événements.

  2. Fournir une classe qui implémente l'interface IObserver ou une classe qui consomme une interface IEnumerable en tant que consommateur d'événements.

  3. Lier ces objets à des requêtes.

Ce modèle de développement ne nécessite pas un important apprentissage ou investissement en programmation pour définir les propriétés temporelles des événements, ni de connaissance des transitions d'état sous-jacentes du modèle de l'adaptateur principal. Vous trouverez ci-dessous certains scénarios dans lesquels ce modèle de développement est approprié :

  1. Requêtes historiques. Alice, analyste financier, identifie des modèles dans les données d'historique du marché en exécutant des requêtes temporelles sur de grands jeux de données. Dans ce cas, le flux d'entrée a une fin définie ; la requête doit se terminer une fois le dernier élément de données traité.

  2. Requêtes appropriées sur des sources actives. Robert, administrateur de serveur, soupçonne une attaque par déni de service. Il identifie la source de l'attaque grâce à une série itérative de requêtes appropriées sur les flux de données réseau qu'il surveille.

  3. Incorporé dans des applications personnalisées. Charles, développeur d'interfaces utilisateur, conçoit des modèles de déplacements de souris en utilisant des requêtes temporelles sur des événements Windows. StreamInsight est incorporé dans l'application personnalisée.

Dans chacun de ces cas, la requête existe uniquement tant que l'application cliente prend en compte les résultats.

Dans cette section

Cette section contient les rubriques suivantes :

Éléments de programmation à prendre en considération pour les sources et récepteurs observables et énumérables

Les sources et récepteurs observables et énumérables sont pris en charge uniquement dans des solutions incorporées

Les sources et récepteurs d'événements observables ou énumérables sont pris en charge uniquement dans le modèle de déploiement hébergé, où le serveur StreamInsight est incorporé dans l'application. Vous ne pouvez pas utiliser de sources et récepteurs d'événements observables ou énumérables avec le modèle de déploiement à serveur autonome ou distant. Pour plus d'informations sur les modèles de déploiement, voir Modèles de déploiement du serveur StreamInsight.

Les fonctionnalités de l'API prennent en charge les spécifications temporelles de StreamInsight

L'API permet une fidélité totale avec le modèle temporel de StreamInsight, notamment en ce qui concerne la mise en file d'attente des événements CTI.

  • Lors des entrées observables et énumérables :

    • les méthodes To[Point|Interval|Edge]Stream incluent dans un wrapper les données d'entrée en tant qu'événements StreamInsight et spécifient les caractéristiques temporelles des données sources ;

    • une méthode d'assistance et les propriétés de la classe AdvanceTimeSettings aident le développeur à spécifier la fréquence à laquelle les événements CTI sont empilés, déterminant ainsi la vivacité des données d'entrée.

  • Lors des sorties observables et énumérables, le développeur peut décider d'incorporer ou non les informations temporelles sous la forme d'événements point, intervalle ou session via les méthodes To[Point|Interval|Edge]Observable et To[Point|Interval|Edge]Enumerable.

La prise en charge observable dépend de Microsoft .NET Framework 4

Si votre application utilise des sources ou récepteurs d'événements qui implémentent les interfaces IObservable ou IObserver :

  • l'application doit référencer l'assembly Microsoft.ComplexEventProcessing.Observable.dll ;

  • l'application doit cibler .NET Framework 4 (et non .NET Framework 4 Client Profile).