Reacting With ReactiveUIAllen Greaves

IntelliTect

System.Reactive ReactiveUI

Technologies

Can be found on NuGet Rx-Main

Can be found on NuGet reactiveui-xaml

Namespaces using System.Reactive using System.Reactive.Linq using System.Reactive.Concurrency using ReactiveUI using ReactiveUI.Xaml

Demo

ToObservable() Converts an enumerable sequence to an observable

sequence Behaves like ToList()

SelectMany( x => … ) Projects a sequence into observable sequences Then flattens these sequences into a sequence

Observable.Start( () => … ) Invokes a function asynchronously

Subscribe( x => … ) Bread and butter of Reactive Kicks off processing of the observable sequence Behaves like ForEach( x => … )

ObserveOnDispatcher() Marshals asynchronous observables onto the dispatcher

thread Behaves like CurrentDispatcher.BeginInvoke() Necessary for WPF

ReactiveObjectReactiveValidatedObject Provides useful extensions ViewModels as ReactiveObjects Validation

[ValidatesViaMethod(…)]

Demo

Select( x => … ) Projects a sequence of elements Behaves like enumerable Select( x => … ) Does not flatten

Observable.Defer( () => … ) Defers function invocation Without it, Select() will go ahead and project all

elements

Merge( … ) Merges many sequences into one sequence Limits the number of in-flight threads Used with Observable.Defer

Other Fun Extensions! Delay( … )

Delays the sequence Buffer( … )

Batches input Interval( … )

Sequence of elements occurring on a set interval Throttle( … )

Ignores values during a specified TimeSpan Timestamp( … )

Timestamps elements in a sequence

Non-Observable a = b + c

a is set to the sum of b and c If b or c updates then a remains the same

Observable a = b + c

a is set to the sum of b and c If b or c updates then a is reevaluated

public interface IObservable<out T>{ IDisposable Subscribe(IObserver<T> observer);}

public interface IObserver<in T>{ void OnNext(T value); void OnError(T error); void OnComplete();}

Demo

this.WhenAny( x => … ) Makes dealing with PropertyChanged notifications easier First real look at events as a sequence

Where( x => … ) Filters elements of a sequence

Demo

new ReactiveCommand( … ) Subscribes to an IObservable for CanExecute()

Makes heavy operations easier Subscribe to the IObservable to receive command elements

UpdateCommand = new ReactiveCommand( this.WhenAny( x => x.FileNames, x => x.Value ) .Select(item => item != null && item.Any()) );

UpdateCommand.Subscribe( (x) => … );

What do you get? Loosely coupled code

Everything is built by hooking up observables Properties can be dumb Prevents having to put code in the getters and setters of bound

properties Easier and more powerful event handling

Handling the PropertyChanged event is a mess Unit Testing

Since our code is much more loosely coupled we can test easier Scheduler

Resources Reactive Extension Guides

http://msdn.microsoft.com/en-us/data/gg577611 101 samples

http://rxwiki.wikidot.com/101samples#toc25 ReactiveUI – Paul Betts

http://www.reactiveui.net/