I have a bunch of Rx tests and samples, but they are on a bitlockered drive and I can't find the key since I put in a new SSD and upgraded to Win8 ... Sad.  

I have some Kinect samples I will post later when I get the chance as well, but I don't have my Kinect here, so I can't test it.  In the meantime I will start with one example where I feel like there is boilerplate C# for no reason, and it's completely missing out on the FromEventPattern operator:

class FileWatcher
{
    public class FileChangedEvent{}

    public FileWatcher(string path, string filter, TimeSpan throttle)
    {
        Path = path;
        Filter = filter;
        Throttle = throttle;
    }

    public string Path { get; private set; }
    public string Filter { get; private set; }
    public TimeSpan Throttle { get; private set; }

    public IObservable<FileChangedEvent> GetObservable()
    {
        return Observable.Create<FileChangedEvent>(observer => {

                FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Path, Filter) { EnableRaisingEvents = true };
                FileSystemEventHandler created = (_, __) => observer.OnNext(new FileChangedEvent());
                FileSystemEventHandler changed = (_, __) => observer.OnNext(new FileChangedEvent());
                RenamedEventHandler renamed = (_, __) => observer.OnNext(new FileChangedEvent());
                FileSystemEventHandler deleted = (_, __) => observer.OnNext(new FileChangedEvent());
                ErrorEventHandler error = (_, errorArg) => observer.OnError(errorArg.GetException());
                
                fileSystemWatcher.Created += created;
                fileSystemWatcher.Changed += changed;
                fileSystemWatcher.Renamed += renamed;
                fileSystemWatcher.Deleted += deleted;

                fileSystemWatcher.Error += error;

                return () => {
                        fileSystemWatcher.Created -= created;
                        fileSystemWatcher.Changed -= changed;
                        fileSystemWatcher.Renamed -= renamed;
                        fileSystemWatcher.Deleted -= deleted;
                        fileSystemWatcher.Error -= error;
                        fileSystemWatcher.Dispose();
                    };
            }).Throttle(Throttle);
    }
}

This could be much simpler, something like this:

var observable =
        Observable.Return(new FileSystemWatcher(@"D:\Documents"))
            .Do(watcher => watcher.EnableRaisingEvents = true)
            .Do(watcher => watcher.IncludeSubdirectories = true)
        .SelectMany(watcher => 
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                h => watcher.Created += h, h => watcher.Created -= h)
            .Select(e => new { e.EventArgs.ChangeType, e.EventArgs.FullPath, e.EventArgs.Name })
            .Merge(
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                h => watcher.Deleted += h, h => watcher.Deleted -= h)
            .Select(e => new { e.EventArgs.ChangeType, e.EventArgs.FullPath, e.EventArgs.Name }))
            .Merge(
            Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                h => watcher.Changed += h, h => watcher.Changed -= h)
            .Select(e => new { e.EventArgs.ChangeType, e.EventArgs.FullPath, e.EventArgs.Name }))
            .Merge(
            Observable.FromEventPattern<RenamedEventHandler, RenamedEventArgs>(
                h => watcher.Renamed += h, h => watcher.Renamed -= h)
            .Select(e => new { e.EventArgs.ChangeType, e.EventArgs.FullPath, 
                            Name = e.EventArgs.OldName + " renamed to " + e.EventArgs.Name }))
        );
 

One of the techniques I use to really get Rx is to try to avoid semi-colons as much as possible.  It might not be the best way to write code in the end, but during development it makes you think and ensures that there's no unnecessary variables and potential side-effects.  So, in my samples, you'll see a lot of Do's.  Do's from within the monad make it obvious there is some side-effect.

There isn't a need for Observable.Create in the first snippet, which adds unnecessary complexity,  but I can see why the user might want a IObservable<FileChangedEvent>.  Even if I were to return an IObservable<FileChangedEvent>, I would be sure to use Observable.FromEventPattern. 

So, which is easier to understand at a glance?  This may not be the best example, because I would normally want to eliminate duplicate calls to Observable.FromEventPattern, but that's not easy to do because you can't pass a watcher.Deleted event around.  However, the code, in my opinion is easier to understand because you can start at the top, read down to the bottom and there is no surprises as to what it will do, even though things like the order of events is completely irrelevant.

More/better examples with the Kinect later....