There is a fair challenge of the guidance on stackoverflow.
http://stackoverflow.com/questions/34675045/should-subscribeon-and-observeon-only-be-invoked-by-the-final-subscriber/34699242?noredirect=1#comment57305296_34699242

Perhaps showing the work executed on the threads as swimlanes or sequence diagrams might help explain the issue. It may also help illuminate when the guidance can be ignored.

Other resources - http://introtorx.com/Content/v1.0.10621.0/15_SchedulingAndThreading.html

As pointed out in this post:

http://stackoverflow.com/questions/18477018/rx-and-tasks-cancel-running-task-when-new-task-is-spawned/18493158#18493158

ToObservable does not really offer Cancellation support as there is no way to pass in a CancelationToken. Favor the Observable.FromAsync(Func<CancelationToken, Task>) method instead.

Show how to wait for one event to occur before attempting another event.
Give examples of when this is useful.

• Waiting for Config/Permissions to be loaded
  • Re-executing when config/permissions change
• Login before execution
  • Renewing token before expected expiry
• Getting dependent data for another method call
• Starting (and Stopping) a service before subscribing to it (leveraging a RefCounted observable, as a field on a singleton, with a finally to call remote/async stop?)

Operators that should be showcased:

• SelectMany
• Switch
• Replay(1) & RefCount()

In one of your recipes, you define an extension method to create an observer for property changes:

public static IObservable<TProperty> OnPropertyChanges<T, TProperty>(this T source, Expression<Func<T, TProperty>> property)
    where T : INotifyPropertyChanged
{
    return  Observable.Create<TProperty>(o=>
    {
        var propertyName = property.GetPropertyInfo().Name;
        var propertySelector = property.Compile();

        return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
                        handler => handler.Invoke,
                        h => source.PropertyChanged += h,
                        h => source.PropertyChanged -= h)
                    .Where(e => e.EventArgs.PropertyName == propertyName)
                    .Select(e => propertySelector(source))
                    .Subscribe(o);
    });
}

Is there a reason why you wrap this in a call to Observable.Create() ? If I understand correctly, the only difference this will make is that the two lines of code that get the property name and compile the property selector will be executed for every subscriber, which is not necessary and even hurts performance.

The following code does the same thing and prevents the calls to GetPropertyInfo() and .Compile() for every subscriber:

public static IObservable<TProperty> OnPropertyChanges<T, TProperty>(this T source, Expression<Func<T, TProperty>> property)
    where T : INotifyPropertyChanged
{
    var propertyName = property.GetPropertyInfo().Name;
    var propertySelector = property.Compile();

    return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
                    handler => handler.Invoke,
                    h => source.PropertyChanged += h,
                    h => source.PropertyChanged -= h)
                .Where(e => e.EventArgs.PropertyName == propertyName)
                .Select(e => propertySelector(source));
}

Am I missing something obvious?

Walk a user through various uses of the TestSchedulers:

• Advancing time By/To. Create an ExtMeth to take a TimeSpan so we dont always convert to ticks
• Show the CreateObserver
• Show the difference between the Create Hot/Cold sequence
• Experiment with Timers/Buffer/Recursive scheduling

Link from gist [https://gist.github.com/Dorus/92d9d5336eacdea77d8a]

From Qiming (https://github.com/qooroo)

The SkipUntil and TakeUntil chapter only refers to SkipUntil and 'TakeWhilenotTakeUntil`

Can the new nameof feature in C# be used, and if so what impact does that have on the performance measurements in https://github.com/LeeCampbell/RxCookbook/blob/master/Model/PropertyChange.md#excess-garbage ?

The ever popular last value cache.
Often required, poorly implemented.

Potential implementations should/could:

• Take a single sequence and partition it with group by and cache the last value of each
• Only cache the last shared value
• Provide an GetOrAdd(TKey, Func<TKey, IObservable>) method.
• Allow disposal to trash the whole thing.

Complete the partially written Model/ObserveLatestOn.md recipe.

Provide help to questions like [http://codereview.stackexchange.com/questions/89961/rx-net-file-watcher]

Walk through the issues with FileSystemWatcher and then link back to polling solution from #22

Create a sample of how to use Rx with Bluetooth

This question in SO (http://stackoverflow.com/questions/37687605/rx-net-message-parser) asks a very valid question of how do I parse some stream of bytes into messages based on a set of rules. The rules however require knowledge of where you are in parsing logic

• are you in the header, the body or in between messages?
• was the previous byte and escape/control character?
• if you are in the body, was the previous byte that is a control character itself escaped?

Thus basic Rx operators are not enough. You can get so far with Buffer(2,1) but it fails in some edge cases.

It would be good to really clean up the example into a recipe. Perhaps using Stateless as the state machine?

Either show how to build a query that allows a user to observe ObjA.PropB.SubPropC by leaveraging Switch e.g.

ObjA.WhenPropertyChanges(vm=>vm.PropB)
    .Select(b=>b.WhenPropertyChanges(vm=>vm.SubPropC))
    .Switch()  

We could potentially extend this to build an Expression builder so you could just

ObjA.WhenPropertyChanges(vm=>vm.PropB.SubPropC)

It would be great to finally create the static code analysis tools that help enforce/catch the Rx Guidelines.

• Implementing IObservable<T> or IObserver<T>
• Not disposing
• Not providing and OnError handler

Create a simple example of a WebSocket server and Client

Link solution to http://stackoverflow.com/questions/37374934/observable-using-websocket-receiveasync-aborts-and-cancels-early

Create a post that provides a template of how to ask a CMVE question regarding Rx.

• Marble diagram
• input source via testObservables
• some attempt at the query
• the expectations

Extend the INPC samples to also allow for getting the initial value. The difficulty here is providing a thread-safe implementation.
Trying to get the current value and subscribing to the change sequence has an unavoidable race condition.

Show an example of using Rx over EventStore

I see often a request for something like a Buffer(TimeSpan), but they also want to have some other trigger that can invoke a flush of the buffer.
It seems that this would be a good case of showing how to use GroupJoin

http://stackoverflow.com/questions/33775889/rx-buffer-with-timeout-since-first-new-group-element

Provide a long form answer for rhis post with a build up to the answer and tests: http://stackoverflow.com/questions/33714408/database-polling-with-reactive-extensions/33739633#33739633

Complete the partially completed TibRv recipe

James World with Wilka Hudson has produced a CAS implementation of ObserveLatestOn here [http://www.zerobugbuild.com/?p=192].

Add it to the perf tests too

Why not use Buffer(2,1) instead of ZipSkip?

Also typo yeild.

RxJs (and hopefully soon Rx.NET and others) supports wrting your Rx test with the visual aid of Marble diagrams.

https://github.com/ReactiveX/rxjs/blob/master/doc/writing-marble-tests.md
https://github.com/ReactiveX/rxjs/blob/master/spec/operators/bufferTime-spec.ts

Create an implementation of TWAP and VWAP. This could be linked to from IntroToRx 17_SequencesOfCoincidence.html#GroupJoin

IEnumerble
yeild

As this post requests http://stackoverflow.com/questions/35606136/rx-buffer-without-empty-calls-to-subscriber/35616332#35616332, he would like to have a buffer run at 50ms. However when no values are found during the window, he doesn't want a buffer to be yielded. He could use .Where(buffer=>buffer.Any()) but this doesn't help with the GC pressure he may incur.

Can we build a low allocation version of Buffer?

Show how you can await observable sequences, and what implications it has for your code.

Create an example of how to use Rx with basic/raw sockets.