Rx.NET, from the inside out - Codemotion 2018

Rx .NET
Stas Rivkin
From inside out
@stas_rivkin

Tasks
Not lazy
Not restartble
Feature description
Testable
3
Why Rx?
@stas_rivkin

Agenda
History
Build the Rx API – Observables inside-out
• All about the callbacks
• First building blocks
• Different Rx operators
Live demos
• Google search
• Drag and drop
“Cold” vs “Hot”
Summary & references
4
@stas_rivkin

About Me
More than 6 years of hands on with various technologies
• .NET stack (desktop mainly)
• Angular
• NodeJS
https://blog.oz-code.com/author/stasr
5
@stas_rivkin
Senior software consultant

interface IEnumerable<out T>
{
IEnumerator<T> GetEnumerator();
}
interface IObserver<in T>
{
void OnNext(T value);
void OnError(Exception error);
void OnCompleted();
}
interface IEnumerable<out T>
{
IEnumerator<T> GetEnumerator();
}
Eric Meijer
Push & Pull models
https://goo.gl/2wzXbe
PRO Tip – 36m:00
2009 – Rx released
Rx History
6
@stas_rivkin
interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> obs);
}
interface IEnumerator<out T>: IDisposable
{
bool MoveNext();
T Current { get; }
}
interface IEnumerator<out T>: IDisposable
{
bool MoveNext();
T Current { get; }
}

static void Main(string[] args)
{
Console.WriteLine("Before");
var list = new List<int>(new[] { 10, 20, 30, 40, 50, 60 });
list.ForEach(num => Console.WriteLine(num));
Console.WriteLine("After");
}
All About the Callbacks
7
@stas_rivkin

public class Program
{
{
Button myBtn = new Button();
myBtn.Click += MyBtnOnClick;
}
private static void MyBtnOnClick(object sender, EventArgs eventArgs)
{
Console.WriteLine("Clicked");
}
}
public class Button
{
public event EventHandler Click;
public void RaiseClickEvent() => Click?.Invoke(this, EventArgs.Empty);
}
8
@stas_rivkin

static async Task Main(string[] args) => await RunAsync(OnNext);
private static async Task RunAsync(
Action<string> onNext)
{
WebClient client = new WebClient();
onNext(await client.DownloadStringTaskAsync(“some-URL”));
}
private static void OnNext(string value) => Console.WriteLine(value);
9
@stas_rivkin

static async Task Main(string[] args) => await RunAsync(OnNext, OnError)
Action<string> onNext,
Action<Exception> onError)
{
try
{
onNext(await client.DownloadStringTaskAsync(“some-URL”));
}
catch (Exception e) { onError(e); }
}
private static void OnError(Exception e) => Console.WriteLine($":( {e}");
10
@stas_rivkin

static async Task Main(string[] args) => await RunAsync(OnNext, OnError, OnCompleted);
Action<string> onNext,
Action<Exception> onError,
Action onCompleted)
{
try
{
foreach (var id in new []{1,2,3})
{
onNext(await client.DownloadStringTaskAsync($“some-URL/{id}”));
}
onCompleted();
}
catch (Exception e) { onError(e); }
}
private static void OnError(Exception e) => Console.WriteLine($":( {e}");
private static void OnCompleted() => Console.WriteLine("Hooray!");
11
@stas_rivkin

12
“Encapsulate
what varies”
Gang of four
@stas_rivkin

static void Main(string[] args) => NeedData(OnNext, OnError, OnComplete);
public static void NeedData(
Action<int> onNext,
Action onComplete)
{
foreach (var num in new[] { 10, 20, 30 })
{
onNext(num);
}
onComplete();
}
private static void OnNext(int value) => Console.WriteLine(value);
private static void OnError(Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(error);
Console.ResetColor();
}
private static void OnCompleted()
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("done");
}
First Building Blocks
13
//...
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
14
// ...
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
15
// ...
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
16
// ...
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
17
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
18
@stas_rivkin

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
19
@stas_rivkin
var data = NeedData ();
...
public IEnumerable<int> NeedData()
=> new[] { 10, 20, 30 };

Action<int> onNext,
Action onComplete)
{
{
onNext(num);
}
onComplete();
}
{
}
{
}
20
@stas_rivkin

21
{
var observer = new ConsoleObserver();
NeedData(observer);
}
public static void NeedData(ConsoleObserver observer)
{
foreach (var value in new[] { 10, 20, 30 })
{
observer.OnNext(value);
}
observer.OnCompleted();
}
public class ConsoleObserver
{
public void OnNext(int value)
{ ... }
public void OnError(Exception error)
{ ... }
public void OnCompleted()
{ ... }
}
public interface IObserver<in T>
{
void OnCompleted();
}
@stas_rivkin

22
{
void OnCompleted();
}
{
NeedData(observer);
}
public static void NeedData(IObserver<int> observer)
{
{
}
}
@stas_rivkin

23
{
void OnCompleted();
}
{
Subscribe(observer);
}
public static void Subscribe(IObserver<int> observer)
{
{
}
}
@stas_rivkin

public class Observable : IObservable<int>
{
public void Subscribe(IObserver<int> observer)
{
{
}
}
}
public interface IObservable<out T>
{
void Subscribe(IObserver<T> observer);
}
24
{
var observable = new Observable();
observable.Subscribe(observer);
}
@stas_rivkin

25
{
public IDisposable Subscribe(IObserver<int> observer)
{
{
}
return Disposable.Empty;
}
}
public interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> observer);
}
@stas_rivkin
{
var observable = new Observable();
}

26
{
var observable = new Observable(new[]{ 10, 20, 30 });
}
{
private IEumerable<int> _values;
public Observable(IEumerable<int> values)
=> _values = values;
public IDisposable Subscribe(IObserver<int> observer)
{
foreach (var value in _values)
{
}
}
}
@stas_rivkin

27
public class Observable<T> : IObservable<T>
{
private IEumerable<T> _values;
public Observable(IEumerable<T> values)
public IDisposable Subscribe(IObserver<T> observer)
{
{
}
}
}
@stas_rivkin
{
var observable = new Observable(new[]{ 10, 20, 30 });
}

28
public class ToObservable<T> : IObservable<T>
{
private IEnumerable<T> _values;
public ToObservable(IEnumerable<T> values)
{
{
}
}
}
{
var observable = new ToObservable(new[]{ 10, 20, 30 });
}
@stas_rivkin

public static class ObservableExtensions
{
public static IObservable<T> ToObservable<T>
this IEnumerable<T> src)
=> new ToObservable<T>(src);
}
{
IObservable observable = new[]{ 10, 20, 30 }
.ToObservable();
}
IEnumerable -> IObservable
29
@stas_rivkin

{
.ToObservable();
}
Where
30
@stas_rivkin
{
public static IObservable<T> Where<T>(
this IObservable<T> src,
Func<T, bool> filter)
=> new Where<T>(src, filter);
}

Where
31
@stas_rivkin
{
}
{
.ToObservable()
.Where(n => n > 10);
}

Where
32
public class Where<T> : IObservable<T>
{
private IObservable<T> _src;
private Func<T, bool> _filter;
public Where(
IObservable<T> src,
{
_src = src;
_filter = filter;
}
{
//...
}
}
@stas_rivkin

Where
33
public class Where<T> : IObservable<T>,
{
private IObserver<T> _observer;
public Where(
IObservable<T> src,
{
_src = src;
_filter = filter;
}
{
_observer = observer;
return new CompositeDisposable
{
_src.Subscribe(this),
Disposable.Create(() => _observer = null)
};
}
/* */
}
@stas_rivkin
IObserver<T>

Where
34
public class Where<T> : IObservable<T>, IObserver<T>
{
private IObserver<T> _observer;
public Where(
IObservable<T> src,
{
_src = src;
_filter = filter;
}
{ ... }
public void OnNext(T value)
{
if(_filter(value)) _observer.OnNext(value);
}
public void OnError(Exception error) => _observer.OnError(error);
public void OnCompleted() => _observer.OnCompleted();
}
@stas_rivkin

{
.ToObservable()
.Where(n => n > 10);
}
Select
35
{
Func<T,bool> filter)
public static IObservable<TOut> Select<TIn, TOut>(
this IObservable<TIn> src,
Func<TIn, TOut> selector)
=> new Select<TIn, TOut>(src, selector);
}
@stas_rivkin

Select
36
{
.ToObservable()
.Where(n => n > 10)
.Select(n => n * 10);
}
@stas_rivkin
{
Func<T,bool> filter)
public static IObservable<TOut> Select<TIn, TOut>(
this IObservable<TIn> src,
=> new Select<TIn, TOut>(src, selector);
}

public class Select<TIn, TOut> : IObservable<TOut>, IObserver<TIn>
{
private IObservable<TIn> _src;
private Func<TIn, TOut> _selector;
private IObserver<TOut> _observer;
public Select(
IObservable<TIn> src,
{
_src = src;
_selector = selector;
}
public IDisposable Subscribe(IObserver<TOut> observer)
{ ... }
public void OnNext(TIn value)
{
_observer.OnNext(_selector(value));
}
public void OnError(Exception error) => _observer.OnError(error);
public void OnCompleted() => _observer.OnCompleted();
}
Select
37
@stas_rivkin


In Action
38
{
IDisposable subscription = new[]{ 10, 20, 30}
.ToObservable()
.Where(n => n > 10)
.Select(n => n * 10);
.Subscribe(observer);
}
Where(n => n > 10)
Select(n => n * 10)
@stas_rivkin

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
Rx Operators
@stas_rivkin
Timestamp

Google Search
1. At least 3 characters
2. Don’t send the same string again
41
@stas_rivkin

43
Where(newSearchToken => newSearchToken.Length > 2 )

@stas_rivkin

44

Throttle(TimeSpan.FromSeconds(0.5))
0.2sec

@stas_rivkin

45

Throttle(TimeSpan.FromSeconds(0.5))
DistinctUntilChanged()
0.2sec


@stas_rivkin

46
Select(searchToken => SearchService.SearchAsync(searchToken))
REA
REAC
Switch()
REA results are ignored since we
switched to the “REAC” results

@stas_rivkin

var dragObs = mouseMoveObs.SkipUntil(mouseDownObs).TakeUntil(mouseUpObs)
Drag and Drop
47
var mouseDownObs = Observable.FromEventPattern(UIElement, nameof(UIElement.MouseDown));
var mouseMoveObs = Observable.FromEventPattern(UIElement, nameof(UIElement.MouseMove));
var mouseUpObs = Observable.FromEventPattern(UIElement, nameof(UIElement.MouseUp));
.Repeat();
On each mouse-down on your target,
start processing mouse-moves for your target
until a single mouse-up on your target
On each mouse-down on your target,
start processing mouse-moves for your target
until a single mouse-up on your target
;
@stas_rivkin

49
Select(me => me.EventArgs.GetPosition(DrawingControl))
@stas_rivkin

50
SelectMany(point => itemsStream.SelectMany((item,index) => …))itemsStream.SelectMany
@stas_rivkin

51
Observable.Return(new{item,Point = new Point(point.X+index, point.y)})
[0] [1] [2] [3] [4] [n]index:
point.X+index, point.y
@stas_rivkin
“Rx can make text fly”

52
Delay(TimeSpan.FromMilliseconds(index*75), loopScheduler)
Observable.Return(new{item,Point = new Point(point.X+index, point.y)})
[0] [1] [2] [3] [4] [n]index:
[1]*75ms
[2]*75ms
[n]*75ms
@stas_rivkin
“Rx can make text fly”

53
SelectMany(point => itemsStream.SelectMany((item,index) => …))
@stas_rivkin

“Cold” vs “Hot”
54
Observables are “cold” by default
•“Cold” creates a new producer each time a consumer subscribes to it
•“Hot” observables share a single producer with every consumer that
subscribes to them
var aStream = Observable.Where(...).Select(...)
aStream.Subscribe(...); var shared = aStream.Publish().RefCount();
aStream.Subscribe(...);
aStream.Subscribe(...);
shared.Subscribe(...);
@stas_rivkin

Summary
Simple idea – definitely not some magic
Easy to compose between events, callbacks, time-based operations
• Treating events as collections
• Manipulating sets of events with “operators”
Observables are LAZY by nature
• “subscribe” to the Observable sometime in the future
• “dispose” from the observable to cancel & tear down the producer
55
@stas_rivkin

www.reactivex.io
github.com/Reactive-Extensions
www.manning.com/dresher
56
Resources
@stas_rivkin

Thanks for Coming
Q
A ?
@stas_rivkin
GitHub examples:
http://bit.ly/2whyHKt

Rx.NET, from the inside out - Codemotion 2018

More Related Content

What's hot (20)

Similar to Rx.NET, from the inside out - Codemotion 2018 (20)

Recently uploaded (20)

Rx.NET, from the inside out - Codemotion 2018

Editor's Notes