Intro to RX

Reactive Extensions for .Net
Scott Weinstein
Principal
Lab49
weblogs.asp.net/sweinstein / @ScottWeinstein

What is it?
The Reactive Extensions for .Net are a new API from MS Dev labs to enable “Linq over Events”
Why should I care?
Offers a better programming model then Events

Some Concepts

Please sir, can I have some more?

Bid 20, bid 20.2, bid 20.8,…

Pull
For pull, data is processed at the leisure of the consumer.
The consumer “pulls” the next item from the producer
Common examples include:
reading from a file
summing the numbers in an array
iterating though a database query
traversing a directory listing
paging through an Amazon search

Push
For push, data is send via demands of the source.
The producer pushes the data to the consumer.
Common examples include:
Device measurements such as
time
light
heat
User triggered data such as
Mouse & Keyboard events
UI events
Sales transactions
Asynchronous code

Push & Pull
In both scenarios, data moves from the producer to the consumer

Push & Pull in .Net
In .Net Pulled data is exposed via common interface pair
IEnumerable/IEnumerator
There is no other way
Foreach and Linq are build on these interfaces
Pushed data is exposed via
Events
Ad-hoc delegate callbacks
Ad-hoc subscribe/callback interfaces
BeginXXX/EndXXX Async pattern
3rd party attempts at Linq for Pushed data (Clinq,Slinq,PushLinq)
Each implementation is unique is its own special way

LINQ
LINQprovides a composable and standard way to do list manipulations
The Reactive Extensions (RX) attempt to
Provide a common interface for Pushed data
IObservable/IObserver
Enable Linq over Pushed data, providing composiblity and standard operators

DemoSimple Temperature Alerts

Events to Observables Demo

Func and Action and Lambdas
Func<int> a;
Func<int,int,int> add = (a,b) => a+b;
Action<T> t;
Action <T,T> tt;

Some (Category) Theory
There is a formal basis for the RX
Duality, as such, is the assertion that truth is invariant under this operation on statements. In other words, if a statement is true about C, then its dual statement is true about Cop. Also, if a statement is false about C, then its dual has to be false about Cop.
Informally, these conditions state that the dual of a statement is formed by reversing arrows and compositions.
What this means is that if we can create a Dual of IEnumerable then all of Linq will work over pushed data

Dualizing IEnumerator
interface IEnumerator<T>
{
T Current { get; } // but can throw an exception
bool MoveNext();
void Reset(); // not used
}
Reverse the arrows
interface IObserverDraft1<T>
{
SetCurrent(T value); // but need to handle an exception
MoveNext(bool can) ;
}

Dualizing IEnumerator (2/2)
interface IObserverDraft2<T>
{
OnNext(T value);
OnError(Exception ex);
MoveNext(bool can) ; //but called every time!
}
interface IObserver<T>
{
OnNext(T value);
OnError(Exception ex);
OnCompleted(); // only called once
}

Dualizing IEnumerable
interface IEnumerable<T>
{
IEnumerator<T> GetEnumerator();
}
Reverse the arrows
public interface IObservableDraft1<T>
{
// But how do I stop observing?
SetObserver(IObserver<T> obs);
}

Dualizing IEnumerable (2/2)
interface IObservableDraft2<T>
{
Subscribe(IObserver<T> obs);
// can I be more composable?
Unsubscribe(IObserver<T> obs);
}
interface IObservable<T>
{
IDisposable Subscribe(IObserver<T> obs);
}

Terse functional explanation
Enumerable:
() –> (() –> Option<T>)
FuncEnumerable<T> –> Func<Func<Option<T>>>
Observable
(Option<T> –> ()) –> ()
FuncObservable<T> –> Action<Action<Option<T>>>

Combinators
Demo
Implement Where()

Some useful Combinators
CombineLatest
Do
ForkJoin
GroupBy
Scan
HoldUntilChanged
Interval
Merge
ObserveOnDispatcher
Sample
Throttle
Select
SelectMany
Where
Zip

How to create Observables?
Create
CreateWithDisposable
FromAsyncPattern
FromEvent
Generate
ISubject
In general, it’s a mistake to create custom implementations of IObservable or IObserver
When might it be ok to break this rule?

Streaming OLAP Demo
Scan, GroupBy, Where, Zip, Merge, SelectMany

Merge
IObservable<T> a
IObservable<T> b
A.Merge(B) == IObservable<T> ==

Zip
IObservable<T> a
IObservable<Y> b
a.Zip(b, selector) == IObservable<Z> ==

Grouping
IObservable<T>
IGroupedObservable<TKey, TElement>
Key
IObservable<IGroupedObservable<Tkey,TElement>>
KeyA
KeyB
KeyC

Hot & Cold
Observables (and Enumerables) come in two flavors
Hot
Values exist outside of subscription
Cold
Value only exist because of subscription
Cold observables can be prone to side-effects
ToArray() is one method for making cold Enumerables hot, Replay() and Publish for Observables (and now Enumerables)

Hot and Cold Demo

Code vs. Data
RX has an alternate method of representing stream events
Interface defines a code-centric view
OnNext
OnError
OnCompleted
Notification defines a data-centric view
new Notification<T>.OnNext(T next)
Where is this useful?

Schedulers
RX introduces Schedulers for explicit control
Which thread do subscriptions run on
How is time represented
ControlSchedulerCurrentThreadScheduler
DispatcherSchedulerImmediateScheduler
NewThreadSchedulerSynchronizationContextScheduler
TaskPoolSchedulerThreadPoolScheduler

Topics not covered
Joins
Subjects
combine Observability and Enumerablility into a single class.
BehaviorSubject<T>
AsyncSubject<T>
ReplaySubject<T>
Subject<T>

How to get it?
Download from the DevLabs: Reactive Extensions for .NET (Rx) site
.Net 4
In .Net 4 – IObservable/IObserver are part of the BCL
.Net 3.5 SP1
Silverlight 3
Javascript
Current license is “go-live” however the API is still evolving

Resources
Reactive Extensions for .Net
Forums
Videos
http://weblogs.asp.net/sweinstein

Delayed Expensive Search

DemoAsync webpage download

Intro to RX

by Scott Weinstein on Apr 21, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 38

Statistics

Intro to RX — Presentation Transcript