reactive
v6.0.1
Ce référentiel contient quatre bibliothèques conceptuellement liées dans le sens où elles concernent toutes LINQ sur des séquences de choses :
Extensions réactives pour .NET alias Rx.NET ou Rx (System.Reactive) : une bibliothèque pour la programmation événementielle avec un modèle déclaratif composable
AsyncRx.NET (aperçu expérimental) (System.Reactive.Async) : implémentation expérimentale de Rx pour IAsyncObservable<T> offrant une prise en charge async / await plus approfondie
Extensions interactives pour .NET, alias Ix (System.Interactive) : opérateurs LINQ étendus pour IAsyncEnumerable et IEnumerable
LINQ pour IAsyncEnumerable (System.Linq.Async) : implémente les opérateurs LINQ standard pour IAsyncEnumerable
Chacun sera décrit plus loin dans ce README.
La programmation réactive fournit de la clarté lorsque notre code doit répondre aux événements. Les bibliothèques Rx.NET ont été conçues pour permettre aux applications cloud natives de traiter les données en direct de manière fiable et prévisible.
Nous avons écrit un livre GRATUIT qui explique les abstractions vitales qui sous-tendent Rx et montre comment exploiter les fonctionnalités puissantes et étendues intégrées aux bibliothèques Rx.NET.
Basé sur le livre de Lee Campbell de 2010 (aimablement offert au projet), il a été réécrit pour le mettre à jour avec Rx.NET v6.0, .NET 8.0 et les cas d'utilisation natifs du cloud modernes tels que l'IoT et le réel. traitement des données en flux temporel.
L'introduction à Rx.NET est disponible en ligne, sur GitHub, au format PDF et EPUB.
| Canal | réception | AsyncRx | ix | Système.Linq.Async |
|---|---|---|---|---|
| NuGet.org | ||||
| Aperçu de NuGet.org (si plus récent que la version) | ||||
| Construire | Construit dans le cadre de Ix | |||
| Azuré Artefacts | ||||
| Historique des versions | Historique des versions | Historique des versions | Historique des versions |
Pour les builds nocturnes, configurez NuGet pour utiliser ce flux : https://pkgs.dev.azure.com/dotnet/Rx.NET/_packaging/RxNet/nuget/v3/index.json
Retrouvez-nous sur la chaîne #rxnet sur https://reactivex.slack.com/
À l’ère du numérique, les flux de données en direct sont omniprésents. Les applications financières dépendent d’une réponse rapide à des informations opportunes. Les réseaux informatiques ont toujours été capables de fournir des informations détaillées sur leur santé et leur fonctionnement. Les sociétés de services publics telles que les fournisseurs d’eau disposent d’un grand nombre d’appareils qui surveillent leurs opérations. L'interface utilisateur et les cadres de création de jeux rapportent les interactions des utilisateurs de manière très détaillée. Les camionnettes de livraison signalent en permanence leurs progrès. Les avions fournissent une télémétrie de performance pour détecter les problèmes de maintenance potentiels avant qu'ils ne deviennent de graves problèmes, et les voitures commencent désormais à faire de même. Beaucoup d’entre nous portent ou transportent des appareils qui suivent notre activité physique et même nos signes vitaux. Et les améliorations apportées à l’apprentissage automatique ont enrichi les informations pouvant être dérivées du volume et de la variété toujours croissants de données en direct.
Mais malgré leur grande diffusion, les flux d’informations en direct ont toujours été des citoyens de seconde zone. Presque tous les langages de programmation ont une manière innée de travailler avec des listes de données (par exemple, des tableaux), mais ces mécanismes ont tendance à présumer que les données pertinentes sont déjà en mémoire, prêtes à être utilisées. Ce qui manque, c'est la vivacité : le fait qu'une source d'information puisse produire de nouvelles données à tout moment, selon son propre calendrier.
Rx élève la prise en charge des flux d'informations en direct au même niveau que celui auquel nous nous attendons pour des éléments tels que les tableaux. Voici un exemple :
var bigTrades = du commerce dans les métiers où trade.Volume > 1_000_000 sélectionnez le commerce ;
Cela utilise la fonctionnalité LINQ de C# pour filtrer trades vers les entités dont le volume est supérieur à un million. Cette syntaxe d’expression de requête n’est qu’un raccourci pour les appels de méthode, nous pourrions donc également l’écrire de cette façon :
var bigTrades = trades.Where(trade => trade.Volume > 1_000_000);
Le comportement exact de ces deux extraits de code (équivalents) dépend du type trades . S'il s'agissait d'un IEnumerable<Trade> , alors cette requête parcourrait simplement la liste et bigTrades serait une séquence énumérable contenant uniquement les objets correspondants. Si trades étaient un objet représentant une table de base de données (par exemple, un DbSet Entity Framework, cela serait traduit en une requête de base de données. Mais si nous utilisons Rx, trades seraient un IObservable<Trade> , un objet signalant les événements en direct au fur et à mesure qu'ils Et bigTrades serait également un IObservable<Trade> , signalant uniquement les transactions d'un volume supérieur à un million. Nous pouvons fournir à Rx un rappel à appeler chaque fois qu'une source observable a quelque chose pour. nous:
bigTrades.Subscribe(t => Console.WriteLine($"{t.Symbol} : échange avec le volume {t.Volume}"));Les deux fonctionnalités clés de Rx sont :
une manière clairement définie de représenter et de gérer des séquences de données en direct ( IObservable<T> )
un ensemble d'opérateurs (tels que l'opérateur Where que nous venons de montrer) permettant d'exprimer la logique de traitement des événements de manière déclarative
Rx a été appliqué avec succès dans les interfaces utilisateur. (Cela est également vrai en dehors de .NET : RxJS est un spin-off JavaScript de Rx, et il est très populaire dans le code de l'interface utilisateur.) https://github.com/reactiveui/reactiveui utilise en profondeur Rx pour prendre en charge Développement de l'interface utilisateur .NET.
Ian Griffiths a présenté un aperçu concis de 60 minutes des extensions réactives pour .NET lors de la rencontre dotnetsheff en 2020. D'autres vidéos sont disponibles sur la liste de lecture Rx.
Bien que Rx soit un moyen naturel de modéliser des processus asynchrones, sa conception originale supposait que le code agissant sur les notifications s'exécuterait de manière synchrone. En effet, la conception de Rx est antérieure aux fonctionnalités du langage async / await de C#. Ainsi, bien que Rx propose des adaptateurs capables de convertir entre IObservable<T> et Task<T> , il y avait certains cas où async n'était pas une option.
AsyncRx.Net lève cette restriction en définissant IAsyncObservable<T> . Cela permet aux observateurs d'utiliser du code asynchrone. Par exemple, si bigTrades était un IAsyncObservable<Trade> nous pourrions écrire ceci :
bigTrades.Subscribe(async t => wait bigTradeStore.LogTradeAsync(t));
AsyncRx.Net est actuellement en version préliminaire.
Rx définit tous les opérateurs LINQ standards disponibles pour d'autres fournisseurs, mais il ajoute également de nombreux opérateurs supplémentaires. Par exemple, il définit Scan , qui effectue le même traitement de base que l'opérateur Aggregate standard, mais au lieu de produire un résultat unique après le traitement de chaque élément, il produit une séquence contenant la valeur agrégée après chaque étape. (Par exemple, si l'opération en cours d'agrégation est une addition, Aggregate renverrait la somme totale en une seule sortie, tandis que Scan produirait un total cumulé pour chaque entrée. Étant donné une séquence [1,2,3] , Aggregate((a, x) => a + x) produit seulement 6 , alors que Scan produirait [1,3,6] .)
Certains des opérateurs supplémentaires définis par Rx ne sont utiles que lorsque vous travaillez avec des événements. Mais certains sont applicables à des séquences de toute nature. Ainsi, les extensions interactives (Ix en abrégé) définissent des implémentations pour IEnumerable<T> . Ix est en fait une extension de LINQ to Objects, ajoutant de nombreux opérateurs supplémentaires. (Son utilité est confirmée par le fait que les bibliothèques d'exécution .NET ont, au fil du temps, ajouté certains des opérateurs qui n'étaient auparavant disponibles que dans Ix. Par exemple, .NET 6 a ajouté MinBy et MaxBy , des opérateurs auparavant uniquement définis par IX.)
Cette bibliothèque est appelée « Extensions interactives » car « Interactive » est en quelque sorte l'opposé de « Reactive ». (Le nom ne fait pas référence aux interactions des utilisateurs.)
IAsyncEnumerable ( System.Linq.Async ) L'une des fonctionnalités lancées par Ix était une version asynchrone de IEnumerable<T> . Il s'agit d'un autre exemple de fonctionnalité si utile qu'elle a finalement été ajoutée aux bibliothèques d'exécution .NET : .NET Core 3.0 a introduit IAsyncEnumerable<T> , et la version associée C# (8.0) a ajouté la prise en charge intrinsèque de cette interface avec sa construction await foreach .
Bien que .NET Core 3.0 ait défini IAsyncEnumerable<T> , il n’a ajouté aucune implémentation LINQ correspondante. Alors que IEnumerable<T> prend en charge tous les opérateurs standard tels que Where , GroupBy et SelectMany , .NET n'a aucune implémentation intégrée d'aucun d'entre eux pour IAsyncEnumerable<T> . Cependant, Ix avait dès le début fourni des opérateurs LINQ pour sa version prototype de IAsyncEnumerable<T> . Ainsi, lorsque .NET Core 3.0 a été livré, il était relativement simple de mettre à jour tous ces opérateurs LINQ existants pour qu'ils fonctionnent avec le nouveau IAsyncEnumerable<T> officiel. IAsyncEnumerable<T> .
Ainsi, le package System.Linq.Async NuGet a été créé, fournissant une implémentation LINQ to Objects pour IAsyncEnumerable<T> afin de correspondre à celle déjà intégrée à .NET pour IEnumerable<T> .
Étant donné que tout le code pertinent faisait déjà partie du projet Ix (avec IAsyncEnumerable<T> ayant également été défini à l'origine par ce projet), le package System.Linq.Async NuGet est construit dans le cadre du projet Ix.
Certaines des meilleures façons de contribuer sont d'essayer des choses, de signaler des bogues et de participer à des conversations de conception.
Cloner les sources : git clone https://github.com/dotnet/reactive
Construire, tester et déboguer les sources
Comment contribuer
Demandes de tirage : Ouvert/Fermé
Vous cherchez quelque chose sur quoi travailler ? La liste des problèmes à gagner est un excellent point de départ.
Ce projet a adopté un code de conduite adapté du Contributor Covenant pour clarifier le comportement attendu dans notre communauté. Ce code de conduite a été adopté par de nombreux autres projets. Pour plus d’informations, consultez le Code de conduite.
Ce projet fait partie de la .NET Foundation avec d'autres projets comme le .NET Runtime. La .NET Foundation fournit à ce projet une infrastructure DevOps pour compiler, tester, signer et packager cette solution complexe qui compte plus de 100 millions de téléchargements. Il assure également une tutelle permettant au projet de passer de mainteneur à mainteneur, permettant ainsi la continuité pour la communauté.
Les personnes qui maintiennent actuellement Rx sont :
 Ian Griffiths Hove, Royaume-Uni Le blog de Ian sur endjin.com |  Howard van Rooijen Winchester, Royaume-Uni Le blog de Howard sur endjin.com |
Rx existe depuis environ une décennie et demie, nous devons donc beaucoup à ses créateurs et aux nombreuses personnes qui ont travaillé dessus depuis. Voir le fichier AUTHORS.txt pour une liste complète.
Dans le cadre de la .NET Conf 2023, Ian Griffiths a fait le point sur les efforts visant à moderniser Rx.NET pour la v6.0 et les plans pour la v7.0.
Pour plus d’informations, consultez les discussions suivantes :
Futur emballage Rx.NET
Plan de haut niveau Rx.NET v6.0 et v7.0
Nous avons établi une feuille de route expliquant nos plans à moyen terme pour le développement continu de Rx. Ce diagramme illustre notre vision des plateformes sur lesquelles Rx est utilisé, et les cycles de vie de support prévus pour ces différentes cibles :
