Reactive Extensions (.NET)

The dotnet/reactive repository contains four conceptually related libraries focused on LINQ over sequences. Depending on your needs, you can use one or more of the following:

• Reactive Extensions for .NET (Rx.NET): A library for event-driven programming using a composable, declarative model. It uses IObservable<T> to represent live data streams.
• AsyncRx.NET (Experimental Preview): An implementation of Rx for IAsyncObservable<T> that provides deeper async/await support for observers.
• Interactive Extensions (Ix.NET): Provides extended LINQ operators for both IAsyncEnumerable<T> and IEnumerable<T>. It acts as an extension to LINQ to Objects.
• LINQ for IAsyncEnumerable (System.Linq.Async): Implements standard LINQ operators specifically for IAsyncEnumerable<T>.

Rx.NET is transitioning its architecture to separate core Reactive Extensions functionality from UI-framework-specific implementations (like WPF, Windows Forms, and UWP).

In older versions (v6), the System.Reactive package contained UI-specific types (e.g., DispatcherScheduler), which forced applications to acquire transitive dependencies on WPF or Windows Forms even if they only needed core Rx functionality.

To avoid 'bloat' and unwanted framework dependencies, developers should look for UI-specific functionality in dedicated packages rather than relying on the core System.Reactive package for UI-related schedulers or types.

Reactive Extensions (Rx) allows you to combine multiple observable streams to create complex queries across different data sources (e.g., price feeds, sensor networks, or news feeds). You can restructure streams by partitioning data, processing it, and then recombining it.

Common strategies for combining sequences include:

• Integrated Data: Consuming all inputs as a single deluge of data.
• Sequential Data: Consuming one sequence at a time.
• Paired Data: Pairing values from two sources to be processed together.
• First-Response: Consuming data from the first source that responds to a request.

While SelectMany is a fundamental operator for combining streams, Rx provides specialized combination operators and overloads for operators like TakeUntil and Buffer to solve specific composition problems more efficiently.

Schedulers are responsible for three core functions in Reactive Extensions:

1. Determining the context: Deciding which thread or execution context to use for work.
2. Deciding when to execute: Determining if work should happen immediately, after a delay, or at a specific time.
3. Keeping track of time: Managing time-based operations and providing an abstraction for time (which allows for time virtualization in tests).

Most operators use a default scheduler (often CurrentThreadScheduler) unless explicitly provided.

The Ix.NET project provides several libraries for functional and asynchronous programming in .NET:

• System.Interactive: The original library providing extension methods for IEnumerable<T>.
• System.Interactive.Async: Provides similar functionality to System.Interactive but specifically for IAsyncEnumerable<T>.
• System.Linq.Async: Provides a full LINQ implementation for IAsyncEnumerable<T>, including standard operators like Where, Single, and GroupBy that are not built into the .NET runtime for asynchronous streams.

Rx.NET (and LINQ) is built on the mathematical concept of Monads. In a practical programming context, a monad is a way to represent a container of items (like IEnumerable<T> or IObservable<T>).

Understanding monads is important because their mathematical properties enable Rx operators to be composed freely. If a .NET type is a monad, it is a candidate for LINQ-style implementations. For Rx, IObservable<T> is a monad.

The ability to freely compose LINQ operators in Rx is not accidental; it is underpinned by mathematical concepts from category theory. Understanding these concepts explains why Rx components integrate so reliably. The three primary mathematical concepts that standard LINQ operators can be expressed in terms of are:

• Monads
• Catamorphisms
• Anamorphisms

Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs. It is built on three primary pillars:

1. Observables: Represent asynchronous data streams using the IObservable<T> interface.
2. LINQ Operators: Query asynchronous data streams using LINQ-style extension methods (e.g., filtering, projecting, aggregating, and time-based operations).
3. Schedulers: Parameterize concurrency within the asynchronous data streams.

Rx allows you to subscribe to an event stream using the IObserver<T> interface, which is notified by the IObservable<T> whenever an event occurs. It handles cancellation, exceptions, and synchronization gracefully through its extension methods.

Rx operators can be categorized by how they interact with the observable sequence based on functional programming concepts:

• Anamorphisms (Enter the sequence): Operations that create an IObservable<T> from a source. Examples include Generate, Range, and Return.
• Bind (Modify the sequence): Operations that transform an IObservable<T1> into an IObservable<T2>. Examples include SelectMany, Select, and Where.
• Catamorphisms (Leave the sequence): Operations that logically move from IObservable<T1> to a single value T2 (though in practice they often return an IObservable<T2> that produces a single value). Examples include Aggregate, Sum, Min, and Max.