An introduction to the Reactive Extensions (Rx) framework by Microsoft. Rx provides a simpler event model for handling streams of events in asynchronous and event based programs

1. 1
Introduction to Reactive Extensions
Peter Goodman
An Introduction to Reactive
Extensions

2. 2
Introduction to Reactive Extensions
What are Reactive Extensions?

3. 3
Introduction to Reactive Extensions
What are Reactive Extensions?

4. 4
Introduction to Reactive Extensions
What are Reactive Extensions?

5. 5
Introduction to Reactive Extensions
What are Reactive Extensions?

6. 6
Introduction to Reactive Extensions
Events in .Net
form1.MouseMove += (sender, args) => {
if (args.Location.X == args.Location.Y)
// I’d like to raise another event
};
form1.MouseMove -= /* what goes here? */

7. 7
Introduction to Reactive Extensions
Collections are Enumerables
interface IEnumerable<out T>
{
IEnumerator<T> GetEnumerator();
}
interface IEnumerator<out T> : IDisposable
{
bool MoveNext();
T Current { get; }
void Reset();
}

8. 8
Introduction to Reactive Extensions
What if events were collections?
 Collection
Move Next Move Next Move Next Move Next Move Next Move Next
 Event Stream
TIME
OnNext OnNext OnNext OnNext OnNext OnNext

9. 9
Introduction to Reactive Extensions
Observables
interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> observer);
}
interface IObserver<in T>
{
void OnNext(T value);
void OnError(Exception ex);
void OnCompleted();
}

10. 10
Introduction to Reactive Extensions
Summary Push vs Pull
Application
Interactive
MoveNext
Reactive
Got next?
OnNext
Have next!
IEnumerable<T> IObservable<T>
IEnumerator<T> IObserver<T>
Environment

11. 11
Introduction to Reactive Extensions
Creating Observables - Primitive
OnCompleted
.Empty<int>() new int[0]
OnNext
.Return(42) new[] { 42 }
OnError
.Throw<int>(ex) Throwing iterator
.Never<int>()
Iterator that got stuck
Notion of time

12. 12
Introduction to Reactive Extensions
Creating Observables - Range
OnNext(0) OnNext(1) OnNext(2)
.Range(0, 3)
yield 0 yield 1 yield 2
.Range(0, 3)

13. 13
Introduction to Reactive Extensions
Generating values and Subscribing
A variant with time notion Hypothetical anonymous
exists (GenerateWithTime) iterator syntax in C#
o = Observable.Generate( e = new IEnumerable<int> {
0, for (int i = 0;
i => i < 10, i < 10;
i => i + 1, i++)
i => i * i yield return i * i;
);
};
Asynchronous Synchronous
o.Subscribe(x => { foreach (var x in e) {
Console.WriteLine(x); Console.WriteLine(x);
}); }

14. 14
Introduction to Reactive Extensions
Subscribing
IObservable<int> o = Observable.Create<int>(observer => {
// Assume we introduce concurrency (see later)…
observer.OnNext(42);
observer.OnCompleted();
});
IDisposable subscription = o.Subscribe(
onNext: x => { Console.WriteLine("Next: " + x); },
onError: ex => { Console.WriteLine("Oops: " + ex); },
onCompleted: () => { Console.WriteLine("Done"); }
);

15. 15
Introduction to Reactive Extensions
DEMO
Generating events and subscribing to them

16. 16
Introduction to Reactive Extensions
Observable Querying
 Observables are sources of data
 Data is sent to you (push based)
 Extra (optional) notion of time.
 Hence we can query over them
// Producing an IObservable<Point> using Select
var from in Observable MouseEventArgs
select .Location
// Filtering for the first bisector using Where
var from in
where
select

17. 17
Introduction to Reactive Extensions
DEMO
Querying, Composition and introducing Concurrency

18. 18
Introduction to Reactive Extensions
Introducing Asynchrony
 An Asynchronous operation can be thought of as an
Observable that returns a single value and completes.
 FromAsync
 Takes an APM method pair (BeginExecute, EndExecute) and
creates an Observable
 ToAsync
 Takes a method and creates an Observable (Like TPL)

19. 19
Introduction to Reactive Extensions
Introducing Concurrency
 Many operators in Rx introduce Concurrency
 Throttle
 Interval
 Delay
 BufferWithTime
 Generally they provide an overload to supply a Scheduler
 ImmediateScheduler – Static Immediate
 CurrentThreadScheduler – Placed on a queue for the current thread
 NewThreadScheduler – Spawn a new Thread
 DispatcherScheduler - Silverlight
 TaskPoolScheduler - TPL
 ThreadPoolScheduler

20. 20
Introduction to Reactive Extensions
Concurrency and Synchronization
•
var Observable.Return Scheduler.ThreadPool
" "
•
.ObserveOnDispatcher()
" "

21. 21
Introduction to Reactive Extensions
DEMO
Synchronization

22. 22
Introduction to Reactive Extensions
Rx for JavaScript (RxJS)
 Parity with Rx for .NET
 Set of operators
 Taming asynchronous JS
 JavaScript-specific bindings
 jQuery
 ExtJS
 Dojo
 Prototype
 YUI3
 MooTools
 Bing APIs

23. 23
Introduction to Reactive Extensions
DEMO
Rx for JavaScript

24. 24
Introduction to Reactive Extensions
Reactive Extensions
Questions?

25. 25
Introduction to Reactive Extensions
Resources
 MSDN
 Bart de Smet / Rx (Channel 9)
 Reactive UI
 Pushqa / SignalR

26. 26
Introduction to Reactive Extensions
Contact
 pete@petegoo.com
 http://blog.petegoo.com
 Twitter: @petegoo