Good introduction to the .NET Reactive Framework

Aside from the Microsoft documentation, is there a good introduction and tutorial to the Microsoft Reactive (Rx) framework?

Also, what is a good example (with code) that Reactive makes easier of a programming problem that is challenging to solve using conventional asynchronous coding techniques?

UPDATE: The blog posts below have been superseded by my online book www.IntroToRx.com. It is a comprehensive 19 chapter book available for free. You can browse it on the web, or download the mobi version for your kindle. You can also get it direct from Amazon for a tiny fee (~99c / 77p). If the book doesn't meet your needs or expectations, let me (the Author) know and we will do better for v2.

Thanks for the link to the Hot/Cold post. This is only one part of the full series,

1. Introduction to Rx
2. Static and extension methods
3. Lifetime management – Completing and Unsubscribing
4. Flow control
5. Combining multiple IObservable streams
6. Scheduling and threading
7. Hot and Cold observables
8. Testing Rx
9. Buffer, Window, Join and Group Join

I will keep updating this blog with more Rx introductory stuff.

For more advanced stuff you want to go to the Rx Forum (MSDN).

Here's a wiki site with lots of code examples demonstrating how to use different features of the .NET Rx framework: http://rxwiki.wikidot.com/101samples

I found this to be the most comprehensive site out there, and the one that's quickest to get started with.

MSDN Site for Rx-Framework

For a Developer going deeper, the Source Code

Cool Austrian keynote about Rx

This is the best I have seen: DevCamp 2010 Keynote - Rx: Curing your asynchronous programming blues

Some interesting Videos on Channel 9

Kim Hamilton and Wes Dyer: Inside .NET Rx and IObservable/IObserver in the BCL (VS 2010)

An interview with the creator from Rx: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

An introduction from the creator of Rx

• E2E: Erik Meijer and Wes Dyer - Reactive Framework (Rx) Under the Hood 1 of 2
• E2E: Erik Meijer and Wes Dyer - Reactive Framework (Rx) Under the Hood 2 of 2

An Codeproject Article

Another course first blog with links (new)

Here's an example of something that is easy to do with reactive programming, but messy (if not challenging) with classic events, it draws lines while the mouse button is down. It is readable, there is no explicit state handling:

var pen = new Pen(Color.Red, 3);
var graphics = this.CreateGraphics();

var mouseMoveWhileDown = 
    from md in this.GetMouseDown()
    from mv in this.GetMouseMove().Until(this.GetMouseUp())
    select new Point(mv.X, mv.Y);

mouseMoveWhileDown
    .Pairwise()
    .Subscribe(tup => graphics.DrawLine(pen, tup.Item1, tup.Item2)); 

(I must confess that in that example, Pairwise() is home-grown...)

The most important thing about IObservable is that it is 'composable', just like IEnumerable.

I thouroughly recommend the video mentioned in another answer. In fact there are several different videos on the subject on Channel9:

Once you have gone through some of the basic stuff including the HandsOnLab make sure you check out Lee Campbell's Hot and Cold Observables which took some of the arcane mystery out of Rx for me :)

Bizarrely, the Reactive Extensions homepage links to a dozen videos and blogs but forgets to link to the comprehensive official reference documentation. That's a crying shame, if you know the team, please ask them to fix their website!

• http://msdn.microsoft.com/en-us/library/hh242985(v=vs.103).aspx
• http://msdn.microsoft.com/en-us/library/hh242986(v=vs.103).aspx
• http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable(v=VS.103).aspx

You may find this series of articles (there are four) about reactive LINQ useful: Reactive programming (II.) - Introducing Reactive LINQ.

He has an example of writing a game using it, so it should hopefully be what you are looking for.

I also found Introducing the Reactive Framework Part I on CodeBetter.com. There is a sequel to the first part on the same site.

I hope this will help you.

Play with Rx Sandbox to get a very intuitive view of what the different combinators mean. This is the best learning tool I've seen.

Go through these articles, and in particular, download the related source code and play with it.

• Part I - System.Reactive or the .NET Reactive Extensions (Rx) – Concepts and First Look
• Part II - LINQ To Events - More on .NET Reactive Extensions (Rx)
• Part III - LINQ To Events - Generating GetEventName() Wrapper Methods using T4 Text Templates

Trust this will help

To answer the second question, here is a problem that can benefit a lot from Rx. It's called "Get rich quick".

You have developed a game by the same name and it's selling pretty well. But it is available only at your stores for wholesale. To make the cash processing easier, you have a conveyor belt which flows towards you.

(Please feel free to change the story above :) )

Sales people place bound wads of cash on it with no labels indicating the amount and type of bills in the wad. Your job is to sort and count the money. Later on, when you get more money, you can hire others to help you.

In this case, the source is an asynchronous source of wads of cash (Producer). Your employees and suppliers expect money, but you have to consume the wads, unpack them and use your custom business logic to repackage as appropriate to pay them.

The sales people are running on their own thread, so that they don't have to wait for you to count what they throw on the belt. Your time is best utilized if you are told when more money is available to count, until then you can do other work.

You could represent each wad by a byte[].

This is a fairly common real world situation; when you retrieve any resource [for example, webpages for search engines, images or videos] on a network or data from peripherals, you get them in chunks of bytes (possibly with headers). In a single thread, or in a multi-thread environment that is too difficult to work with, you tend to aggregate and process them. Not any more!!

Jesse Liberty has a book out, published Oct 2011:

[Amazon.com: Programming Reactive Extensions and LINQ][1]

And there's the RxWorkshop videos on Channel9:

[Channel9: RxWorkshop][2]

[1]: http://www.amazon.com/dp/1430237473/ref=sr_1_1?ie=UTF8&qid=1320557393&sr=8-1 "Amazon.com: Programming Reactive Extensions and LINQ" [2]: http://channel9.msdn.com/Series/Rx-Workshop

Does your "excluding Microsoft documentation" clause extend to the videos on Channel 9?

From the creator of the reactive framework Erik Meijer:

• Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Brand new: Getting Started with Rx Extensions for .NET

DEVHOL202 – Curing the asynchronous blues with the Reactive Extensions for .NET (PDF, 2 MB) is the best lab/tutorial I've seen so far. It guides you through the basics of the library, so that you can build and design on what you've learned.

There is also a JavaScript version. Search Google for "Reactive Extensions Hands on Lab".

In addition to Andreas Hoffmann's links (found them very helpful when I was learning Rx)

Here are some of Bart De Smet (a VERY smart guy who explains things really well) Videos:

Kinda a run through of Rx:
Rx - Curing your Asynchronous Programming Blues

Some gory insides + some philosophy, these videos are really enlightening:
Min LINQ - The essence of LINQ
(The above video deals with how LINQ kinda relates to other things, Like Rx)

Observations on IQbservable - The Dual of IQueryable

I liked Introduction to Rx Part 1 - Key types, and it showed the key features.