Reactive applications are designed to handle asynchronous events in a way that maximizes responsiveness, resiliency and elasticity. Reactive Extensions (Rx) is a library created by Microsoft that abstracts away the sources of events and provides tools to handle them in a reactive way. With Rx, filtering events, composing event sources, transforming events and dealing with errors all become much simpler than with traditional tools. Reactive Extensions requires a mind change, thinking about your application as a message hub that knows how to react to messages.

1. MILAN 20/21.11.2015
Talk title: Reactive Extensions 101
Tamir Dresher – CodeValue - @tamir_dresher

2. • Software Architect, Consultant and Instructor
• Software Engineering Lecturer @ Ruppin
Academic Center
@tamir_dresher
tamirdr@codevalue.net
http://www.TamirDresher.com.

3. Your headache relief pill to Asynchronous and
Event based applications
Async
Push
Triggers
Events
Reactive Extensions

4. Reactive Programming concentrates
on the propagation of changes and
their effects
simply put, how to react to
changes and create dataflows
that depend on them
Reactive Programming

5. Social
media
IoT
GPS
External Services
Your System
So Many Sources…

6. Source/
Producer
Target/
Consumer
Producer-Consumer

7. Source/
Producer
Target/
Consumer
Source/
Producer
Source/
Producer
Target/
Consumer
Target/
Consumer
Producer-Consumer

8. IEnumerable<Message> LoadMessages(string hashtag)
{
var statuses = facebook.Search(hashtag);
var tweets = twitter.Search(hashtag);
var updates = linkedin.Search(hashtag);
return statuses.Concat(tweets).Concat(updates);
}
Twitter App
Linkedin
Facebook
Pull Model

9. ???? LoadMessages(string hashtag)
{
facebook.Search(hashtag);
twitter.Search(hashtag);
linkedin.Search(hashtag);
}
DoSomething( )msg
Push Model

10. observable observer
Subscribe(observer)
subscription
OnNext(X1)
OnNext(Xn)
⁞
⁞
IDisposable
Observables and Observers

11. OnCompleted()
OnError(Exception)

observable observer
⁞
Observables and Observers

12. namespace System
{
public interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> observer);
}
public interface IObserver<in T>
{
void OnNext(T value);
void OnError(Exception error);
void OnCompleted();
}
}
Interfaces

13. MILAN 20/21.11.2015
Creating Observables

14. IObservable<Message> ObserveMessages(string hashtag)
{
}
return Observable.Create( async (o) =>
{
});
var messages = await GetMessagesAsync(hashtag);
foreach(var m in messages)
{
o.OnNext(m);
}
o.OnCompleted();
Pull To Push

15. IObservable<Message> ObserveMessages(string hashtag)
{
}
return Observable.Defer( async () =>
{
});
var messages = await GetMessagesAsync(hashtag);
return message.ToObservable();
Built-in Converters

16. Observable.Merge(
facebook.ObserveMessages(hashtag),
twitter.ObserveMessages(hashtag),
linkedin.ObserveMessages(hashtag)
);
Built-in Operators

17. Observable.Range(1, 10)
.Subscribe(x => Console.WriteLine(x));
Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(x => Console.WriteLine(x));
Observable.FromEventPattern(SearchBox, "TextChanged")⁞
⁞
1 sec 1 sec
Observables Factories
⁞

18. MILAN 20/21.11.2015
Observable Queries (Rx Operators)

19. Filtering Projection Partitioning Joins Grouping Set
Element Generation Quantifiers Aggregation Error HandlingTime and
Concurrency
Where
OfType
Select
SelectMany
Materialize
Skip
Take
TakeUntil
CombineLatest
Concat
join
GroupBy
GroupByUntil
Buffer
Distinct
DistinctUntilChanged
Timeout
TimeInterval
ElementAt
First
Single
Range
Repeat
Defer
All
Any
Contains
Sum
Average
Scan
Catch
OnErrorResumeNext
Using

20. Operator2 Creates an IObservable<T3>
IObservable parameters
Operator
1
Subscribe( )
observer
observable
… Operator
N
Operator1
Creates an IObservable<T2>
IObservable<T>
Original source
observer
Subscribe
Composability

21. g(x)
f(x)
Observable Query Pipeline

22. Reactive Search

23. 1. At least 3 characters
2. Don’t overflow server (0.5 sec delay)
3. Don’t send the same string again
4. Discard results if another search was
requested
Reactive Search - Rules

25. Var textChanged =
Observable.FromEventPattern(txt, “TextChanged”)
.Select(_=>txt.Text);
textChanged
.Where(text=>text.Length>3)
.Throttle(TimeSpan.FromSeconds(0.5))
.DistinctUntilChanged()
.SelectMany(text => SearchAsync(text))
.Switch()
.Subscribe(/*handle the results*/);

26. var $input = $('#input'),
$results = $('#results');
Rx.Observable.fromEvent($input, 'keyup')
.map(e => e.target.value)
.filter(text => text.length > 3)
.throttle(500 /* ms */)
.distinctUntilChanged()
.flatMapLatest(searchWikipedia)
.subscribe(data => {
var res = data[1];
$results.empty();
$.each(res, (_, value) => $('<li>' + value + '</li>').appendTo($results));
}, error => {
/* handle any errors */
$results.empty();
$('<li>Error: ' + error + '</li>').appendTo($results);
});

27. MILAN 20/21.11.2015
Abstracting Time and Concurrency

28. Thread Pool
Task Scheduler
other
Schedulers

29. public interface IScheduler
{
DateTimeOffset Now { get; }
IDisposable Schedule<TState>( TState state,
Func<IScheduler, TState, IDisposable> action);
IDisposable Schedule<TState>(TimeSpan dueTime,
TState state,
Func<IScheduler, TState, IDisposable> action);
IDisposable Schedule<TState>(DateTimeOffset dueTime,
TState state,
Func<IScheduler, TState, IDisposable> action);
}

30. //
// Runs a timer on the default scheduler
//
IObservable TimeSpan
//
// Every operator that introduces concurrency
// has an overload with an IScheduler
//
IObservable T TimeSpan
IScheduler scheduler
Parameterizing Concurrency

31. textChanged
.Throttle(TimeSpan.FromSeconds(0.5),
DefaultScheduler.Instance)
.DistinctUntilChanged()
.SelectMany(text => SearchAsync(text))
.Switch()
.Subscribe(/*handle the results*/);

32. //
// runs the observer callbacks on the specified
// scheduler.
//
IObservable T T IScheduler
//
// runs the observer subscription and unsubsciption on
// the specified scheduler.
//
IObservable T T IScheduler
Changing Execution Context

33. textChanged
.Throttle(TimeSpan.FromSeconds(0.5))
.DistinctUntilChanged()
.SelectMany(text => SearchAsync(text))
.Switch()
.ObserveOn(DispatcherScheduler.Current)
.Subscribe(/*handle the results*/);
Changing Execution Context

34. textChanged
.Throttle(TimeSpan.FromSeconds(0.5))
.DistinctUntilChanged()
.SelectMany(text => SearchAsync(text))
.Switch()
.ObserveOnDispatcher()
.Subscribe(/*handle the results*/);
Changing Execution Context

35. http://blogs.msdn.com/b/rxteam/archive/2012/06/14/testing-rx-queries-using-virtual-time-scheduling.aspx
Virtualizing Time

36. Your headache relief pill to Asynchronous and
Event based applications
Async
Push
Triggers
Events
Reactive Extensions

37. Thank You
www.manning.com/dresher www.reactivex.io github.com/Reactive-Extensions
Discount code:
ctwcodemot

38. MILAN 20/21.11.2015 - Tamir Dresher – Rx 101
Leave your feedback on Joind.in!
https://m.joind.in/event/codemotion-milan-2015
Presenter contact details
t: @tamir_dresher
e: tamirdr@codevalue.net
b: TamirDresher.com
w: www.codevalue.net