We all want our applications to be responsible, reliable and testable. But event-driven paradigm sometimes could lead us to obscured or, even worse, messy code. Let’s look into the world, where generated data, background tasks and events are stuck together as asynchronous data streams to achieve a better result.

1. Understanding reactive programming
with Microsoft Reactive Extensions
Oleksandr Zhevzhyk, 2017

2. WHY REACTIVE?
● Have a curious interface (-= and +=)
● Are difficult to compose
● Don't offer the ability to be easily queried over time
● Provide almost no help for concurrency or multithreaded applications
● No blocking while waiting for a result
● The result is pushed to you when it is ready
● Developers need tools to react to pushed data
EVENTS
● Have nothing to do with events
● Handling exceptions, cancellation and synchronization is difficult
● Much better that events, but still difficult to compose
TASKS
REACTIVE IS THE NEW BLACK
REACTIVE PROGRAMMING IS PROGRAMMING WITH ASYNCHRONOUS DATA STREAMS

3. RX: HELPFUL RESOURCES
GitHub
https://github.com/Reactive-Extensions
NuGet
System.Reactive (main library)
> Install-Package System.Reactive
MSDN
https://msdn.microsoft.com/library/hh242985.aspx
“Intro to Rx” by Lee Campbell
http://introtorx.com
Online / Kindle / EPUBStack Overflow
system.reactive tag
http://stackoverflow.com/questions/tagged/system.reactive

4. RX: IMPLEMENTATIONS
Rx.NET - Reactive Extensions for .NET
RxJS - Reactive Extensions for JavaScript
RxJS-ExtJS - Ext JS Bindings for RxJS
rx.angular.js - AngularJS Bindings for RxJS
RxJS-DOM - HTML DOM Bindings for RxJS
RxCpp - Reactive Extensions for C++
Rx.ObjC - Reactive Extensions for Objective C
RxPy - Reactive Extensions for Python

5. WHAT IS RX?
Rx is a library for composing asynchronous and event-based programs using
observable sequences and LINQ-style query operators.
With Rx you:
- represent asynchronous data streams with Observables
- query asynchronous data streams using LINQ operators
- control the concurrency in the asynchronous data streams using Schedulers.
Rx = Observables + LINQ + Schedulers

6. OnNext* (OnCompleted | OnError)?
OBSERVABLE: GRAMMAR

7. OBSERVABLE: CORE INTERFACES
IObservable<T>
.Subscribe (
Action<T> onNext,
Action<Exception> onError,
Action onCompleted)
IObserver<T>
.OnNext (T value)
.OnCompleted ()
.OnError(Exception ex)
IObservable<string> namesObservable = ...;
namesObservable.Subscribe(
name => this.List.Add(name),
ex => this.LogService.LogException(ex);
() => this.RaiseNamesReady(EventArgs.Empty));

8. OBSERVABLE: CHAIN

9. OBSERVABLE: FACTORIES#1
Observable.Never<int>():
∅
Observable.Empty<bool>():
OnCompleted
Observable.Generate(1, x => x < 6, x => x + 2, x => x*x):
1 → 9 → 25 → OnCompleted
Observable.Throw<float>():
OnError
Observable.Return(“abc”):
“abc” → OnCompleted

10. OBSERVABLE: FACTORIES#2
ConsoleCancelEventArgs → ConsoleCancelEventArgs → … (∞)
Observable.FromEventPattern<ConsoleCancelEventHandler,
ConsoleCancelEventArgs>(
h => Console.CancelKeyPress += h,
h => Console.CancelKeyPress -= h);
var fileStream = new FileStream(file, FileMode.Open);
var observableFactory = Observable.FromAsyncPattern<byte[], int, int, int>(
fileStream.BeginRead,
fileStream.EndRead);
var bytes = new byte[fileStream.Length];
observableFactory(bytes, 0, fileStream.Length)
.Subscribe(actualRead => { /*process bytes*/ });
actualRead → OnCompleted
FROM
APM
FROM
EVENT

11. OBSERVABLE: FACTORIES#3
Observable.FromAsync(() =>
Task.Factory.StartNew(() =>
{
Thread.Sleep(5000);
return "404";
}));
FROM
TASK
“404” → OnCompleted
Observable.Using(
() => new FileStream(@"C:movie.mkv", FileMode.Open),
fs => this.ReadFileObservable(fs));
FROM
IDISPOSABLE

12. OBSERVABLE: FACTORIES#4
Bob → Bill → Alice → OnCompleted
var names = Observable.Create<string>(
observer =>
{
observer.OnNext("Bob");
observer.OnNext("Bill");
observer.OnNext("Alice");
observer.OnCompleted();
return Disposable.Empty;
});
Not asynchronous
Not cancellable
var observable = Observable.Create<int>(observer => {
var cd = new CancellationDisposable();
var pause = TimeSpan.FromSeconds(3);
int counter = 0;
Action action = () => {
if (!cd.Token.IsCancellationRequested) {
observer.OnNext(++counter);
if (counter == 5)
observer.OnCompleted();
else
scheduler.Schedule(pause, action);
}
};
scheduler.Schedule(action);
return cd;
});
1 → 2 → 3 → 4 → 5 → OnCompleted

13. OBSERVABLE: CANCELLATION
Subscribe() returns an IDisposable. Keep it.
public void Initialize()
{
this._updateUriDisposable = Observable
.FromEventPattern<EventHandler<UriChangedEventArgs>, UriChangedEventArgs>(
h => this.Options.UriChanged += h,
h => this.Options.UriChanged -= h)
.SelectMany(args => this.RestRequestService.Get(args.EventArgs.Uri, Scheduler.ThreadPool))
.ObserveOn(this.Dispatcher)
.Subscribe(
response => this.WebView.Update(response),
ex => this.HandleError(ex));
}
public void Close() { this._updateUriDisposable.Dispose(); }
Call Dispose on it to stop the Observable.

14. OBSERVABLE: CLEANUP
RX IS TIDY WHEN
Observable has finished with
OnCompleted or OnError
Observable was manually
stopped by Disposable
var changedDisposable = Observable.FromEventPattern(model, nameof(model.Changed))
.Finally(() => Console.WriteLine("Disposed!"))
.Subscribe();
//...
changedDisposable.Dispose();
Use Finally()
when you want
to track disposal
of the data stream

15. LINQ: OVERVIEW
- projection
- filtering
- aggregation
- composing
- time-based operations
You could think:
RX is LINQ to events

16. LINQ: FILTERING
Where
Take / TakeWhile
Skip / SkipWhile
FirstAsync
LastAsync
Observable
.FromEventPattern(
h => textBox.KeyPress += h,
h => textBox.KeyPress -= h)
.Where(_ => _.EventArgs.KeyCode == Keys.Enter)
.Skip(10)
.Take(3)
.FirstAsync()
.Subscribe(_ => { });
EventPattern → OnCompleted

17. LINQ: PROJECTION
Select
Observable.Return(100)
.Select(num => num.ToString())
.Subscribe(str => Console.Write(str));
IObservable<T1> → IObservable<T2>
Select + Switch
SelectMany observable123.SelectMany(num => observableABCD)
observable123.Select(n => observableABCD).Switch()
IObservable<T1> → IObservable<IObservable<T2>>

18. LINQ: PROJECTION#SELECT MANY
observable123
.SelectMany(num => observableABCD)
.Subscribe(letter => Console.WriteLine(letter));

19. LINQ: PROJECTION#SELECT+SWITCH
observable123
.Select(num => observableABCD)
.Switch()
.Subscribe(letter => Console.WriteLine(letter));

20. LINQ: AGGREGATION
ToArray
GroupBy
Aggregate
All
Any
observable123.ToArray().Subscribe(array => { });
[1, 2, 3] → OnCompleted
All aggregation functions produce
an observable with an aggregated result!
...
observable123
.SelectMany(num => observableABCD)
.GroupBy(l => l)
.Subscribe(grouped => grouped
.Aggregate("", (l, res) => res + l)
.Subscribe(aggr => { }));
“AAA” → “BBB” → “CCC” → “DDD” → OnCompleted

21. LINQ: COMPOSING
Fork/Join
Observable
.When(observableABCD
.And(observable123)
.Then((l, n) =>
new {Letter = l, Number = n}))
.Subscribe(pair => { });
{“A”, 1} → {“B”,2} → {“C”,3} → OnCompleted
CombineLatest
Observable
.CombineLatest(
observable123,
observableABCD,
(l, n) => new { Letter = l, Number = n })
.Subscribe();
{“C”, 1} → {“C”,2} → {“D”,2} → {“D”,3} → OnCompleted
Merge
observable123.Merge(observable789).Subscribe(n => { });
1 → 7 → 2 → 3 → 8 → 9 → OnCompleted
Concat
1 → 2 → 3 → 7 → 8 → 9 → OnCompleted
observable123.Concat(observable789).Subscribe(n => { });
SkipUntil / TakeUntil
observable123
.SkipUntil(observable789)
.Subscribe(n => { });
1 → 2 → OnCompleted

22. RX: SCHEDULERS
By default: single threaded.
IScheduler
Scheduler.CurrentThread
Scheduler.ThreadPool DispatcherScheduler
TestScheduler
- Some Rx methods accept IScheduler
Observable
.Return(“data”, Scheduler.ThreadPool)
.Subscribe(_ => {/*worker thread*/});
- ObserveOn method
observable123
.ObserveOn(Scheduler.ThreadPool)
.Select(n => n.ToString())
.ObserveOn(this.Dispatcher)
.Subscribe(s => { })

23. EXCEPTION HANDLING
Everything what happens in Observable stays in Observable.
Besides onNext/onCompleted in Subscribe!
observable123
.SelectMany(n =>
Observable.When(observableABCD
.And(observableXY)
.Then((l1, l2) => l1 + l2))
.Select(word => ProccessWord(word)))
.Subscribe(_ => { }, ex => { });
Exception!
Exception!
Exception!
_restService.Get(uri, Scheduler.ThreadPool)
.Catch<RestException>(
ex => Observable.Return("[]"))
.Subscribe(data => { });
Swallowing exceptions with Catch method

24. FIELD EXAMPLE
Refresh event
UriChanged event
Closed event
3 async web requests
public IObservable<JArray> DataObservable(Uri uri, string resource)
{
return RestRequestService
.Get(Scheduler.ThreadPool, Options.Uri, resource)
.Catch<RestException>(ex =>
{
this.LogService.LogException(ex);
return "[]";
})
.Select(json => Json.Parse(json));
}
uriChanged.Merge(refreshRequested)
.Do(_ => this.IsBusy = true)
.Select(opt => Observable
.When(this.DataObservable(opt.Uri, "cars")
.And(this.DataObservable(opt.Uri, "trams")
.And(this.DataObservable(opt.Uri, "planes"))
.Then((cars, trams, planes) =>
this.CreateDataModel(cars, trams, planes)))))
.Switch()
.TakeUntil(closeRequested)
.ObserveOn(this.Dispatcher)
.Do(dataModel => this.UpdateView(dataModel))
.Subscribe(
dataModel => this.IsBusy = false,
ex =>
{
this.LogService.LogException(ex);
this.ShowError("Something went wrong:", ex);
});

25. “THANK YOU” → ON COMPLETED