1. Reacting With ReactiveUI
Allen Greaves
IntelliTect

2. Technologies
System.Reactive ReactiveUI
 Can be found on NuGet  Can be found on NuGet
 Rx-Main  reactiveui-xaml

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

4. Demo

5. ToObservable()
 Converts an enumerable sequence to an observable
sequence
 Behaves like ToList()

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

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

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

9. ObserveOnDispatcher()
 Marshals asynchronous observables onto the dispatcher
thread
 Behaves like CurrentDispatcher.BeginInvoke()
 Necessary for WPF

10. ReactiveObject
ReactiveValidatedObject
 Provides useful extensions
 ViewModels as ReactiveObjects
 Validation
 [ValidatesViaMethod(…)]

11. Demo

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

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

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

15. 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

16. 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

17. Observable
a = b + c
 a is set to the sum of b and c
 If b or c updates then a is reevaluated

18. 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();
}

19. Demo

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

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

22. Demo

23. new ReactiveCommand( … )
 Subscribes to an IObservable for CanExecute()
 Makes heavy operations easier
 Subscribe to the IObservable to receive command elements

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

25. 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

26. 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/