The Reactive Extensions for .NET, or Rx as they are usually known, are designed for working with asynchronous and event-based sources of information. Rx provides services that help you orchestrate and synchronize the way your code reacts to data from these kinds of sources. We already saw how to define and subscribe to events in Chapter 9, but Rx offers much more than these basic features. It provides an abstraction for event sources, and a powerful set of operators that makes it far easier to combine and manage multiple streams of events than is possible with the free-for-all that delegates and .NET events provide.
Rx’s fundamental abstraction,
IObservable<T>, represents a sequence of
items, and its operators are defined as extension methods for this
interface. This might sound a lot like LINQ to Objects, and there are
similarities—not only does
IObservable<T> have a lot in common with
IEnumerable<T>, but also Rx
supports almost all of the standard LINQ operators. If you are familiar with
LINQ to Objects, you will also feel at home with Rx. The difference is that
in Rx, sequences are less passive. Unlike
IEnumerable<T>, Rx sources do not wait to be
asked for their items, nor can the consumer of an Rx source demand to be
given the next item. Instead, Rx uses a push model in
which the source notifies its recipients when items are available.
For example, if you’re writing an application that deals with live financial information, such as stock market ...