Table of Contents
1. Getting started with Reactive Extensions
Chapter 1. Reactive programming
1.2. Introducing Reactive Extensions
1.2.2. Rx on the client and server
1.3. Working with reactive systems and the Reactive Manifesto
1.4. Understanding asynchronicity
1.5. Understanding events and streams
2.1. Working with traditional .NET events
2.1.1. Dealing with concurrency
2.1.2. Retrospective on the solution and looking at the future
2.2. Creating your first Rx application
2.3. Writing the event-processing flow
2.3.1. Subscribing to the event
2.3.2. Grouping stocks by symbol
2.3.3. Finding the difference between ticks
Chapter 3. Functional thinking in C#
3.1. The advantages of thinking functionally
3.1.1. Declarative programming style
3.2. First-class and higher-order functions using delegates and lambdas
3.3. Method chaining with extension methods
3.3.1. Extending type behavior with extension methods
3.4. Querying collections with LINQ
3.4.1. What does LINQ look like?
Chapter 4. Creating observable sequences
4.1. Creating streams of data and events with observables
4.1.1. Implementing the IObservable<T> interface
4.1.2. The problem with handcrafted observables
4.2. Creating observables from events
4.2.1. Creating observables that conform to the EventPattern
4.2.2. Events that aren’t following the event pattern
4.3. From enumerables to observables and back
4.4. Using Rx creational operators
Chapter 5. Creating observables from .NET asynchronous types
5.1. Bridging .NET asynchronous types with Rx
5.1.1. Changing the synchronous method to asynchronous
5.1.2. Creating the primes observable
5.1.3. Using async-await in observable creation
5.1.4. Converting tasks to observables
5.2. Creating observables of periodic behavior
5.2.1. Emitting values in time intervals
Chapter 6. Controlling the observer-observable relationship
6.1.1. The observable-observer communication
6.1.2. Creating observers without leaving the pipeline
6.1.3. Not passing OnError and asynchronous observables
6.1.4. Replacing the subscription disposal with cancellation
6.2. Controlling the observable-observer relationship lifetime
6.2.2. Stop emitting notifications at a scheduled time
6.2.3. Discarding items when another observable emits
Chapter 7. Controlling the observable temperature
7.1. Multicasting with subjects
7.1.1. Simple broadcasting with Subject<T>
7.1.2. Representing asynchronous computation with AsyncSubject
7.1.3. Preserving the latest state with BehaviorSubject
7.2. Introducing temperature: cold and hot observables
7.3. Heating and cooling an observable
7.3.2. Using ConnectableObservable
7.3.3. Publishing and multicasting
Chapter 8. Working with basic query operators
8.1. Selecting what’s important (mapping)
8.3.1. Filtering with the Where operator
8.4. Aggregating the observable sequence
8.4.1. Using basic aggregation operators
8.4.2. Finding the maximum and minimum items by condition
8.4.3. Writing your aggregation logic with Aggregate and Scan
Chapter 9. Partitioning and combining observables
9.1.1. Pairing items from observables (zipping)
9.1.2. Combining the latest emitted values
9.1.3. Concatenating observables
9.2. Grouping elements from the observable
9.3. Joining observables (coincidence-based combining)
9.4. Buffers and sliding windows
Chapter 10. Working with Rx concurrency and synchronization
10.1. Controlling concurrency with schedulers
10.1.1. Defining the scheduler
10.2. Using time-based operators
10.2.1. Adding a timestamp to a notification
10.2.2. Adding the time interval between notifications
10.2.3. Adding a time-out policy
10.2.4. Delaying the notifications
10.3. Synchronizing the observable emissions
10.3.1. Changing the observation’s execution context
10.3.2. Changing the subscription/unsubscription execution context
Chapter 11. Error handling and recovery
11.2. Controlling the lifetime of resources
11.2.1. Disposing in a deterministic way
11.3. Dealing with backpressure
Appendix A. Writing asynchronous code in .NET
A.1. Writing asynchronous code
A.2. Asynchronous code in .NET
A.3. Task-Based Asynchronous Pattern
Appendix B. The Rx Disposables library
B.7. MultipleAssignmentDisposable
Appendix C. Testing Rx queries and operators
C.1.1. Writing reactive tests with the TestScheduler
C.1.2. Observing the TestableObservable