Upload
scott-weinstein
View
3.655
Download
16
Embed Size (px)
DESCRIPTION
Introduction to Reactive Extensions for .Net
Citation preview
Reactive Extensions for .Net
Scott WeinsteinPrincipal
Lab49weblogs.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•LINQ provides 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 IEnumeratorinterface 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 IEnumerableinterface IEnumerable<T> { IEnumerator<T> GetEnumerator();}
•Reverse the arrowspublic 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 DemoScan, 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> ==
GroupingT3 T2 T1
IObservable<T>
T3 T2 T1
IGroupedObservable<TKey, TElement>
Key
IObservable<IGroupedObservable<Tkey,TElement>>
T3 T2 T1KeyA
T3 T2 T1KeyB
T3 T2 T1KeyC
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
▫ ControlScheduler CurrentThreadScheduler▫ DispatcherScheduler ImmediateScheduler▫ NewThreadScheduler SynchronizationContextScheduler▫ TaskPoolScheduler ThreadPoolScheduler
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