[WIP] Awaitable store with async saga support

[cmeeren]

This is a work in progress. Posting here as a PR so we can discuss. Particularly interested in what @dcolthorp has to say. Regarding https://github.com/GuillaumeSalles/redux.NET/issues/47#issuecomment-290694783, this PR provides a way of registering sagas using an action observable AND awaiting the completion of all actions in the store. See unit tests for details.

Due to necessity I branched this off of my previous branch (PR #60), hence why the commit from that PR also shows up in this PR.

I've just lumped all code together in one file for now.

The distinct features in this PR are:

• The following two delegates denoting async/blocking sagas:

  • void Saga(action, store)
  • Task AsyncSaga(action, store)

  I'm considering changing this a bit so that they only accept an action parameter, and then have the sagas be returned from a function that accepts the store. Kind of like middleware, where the middleware has access to the store through the function that creates the middleware. Removing the store parameter would make the saga register syntax look cleaner, and also removes the store parameter from sagas that don't need it. Input welcome.

• Two extension methods on IObservable<T> for registering async and non-async sagas.

• ObservableActionStore which exposes an IObservable of actions. Can be dropped in favor of a simple extension to Store if we figure out #63.

• AwaitableStore which exposes DispatchAsync and also has internally accessible member(s) for keeping track of async operations that DispatchAsync should await (currently this is simply a method IDisposable AsyncOperation() to be used in using statements, as seen in the extension method.)

• The IObservable<T> extension methods RunsSaga and RunsAsyncSaga

Things to do before this can be merged:

• [ ] Structure: Where to put the classes and interfaces
• [ ] Determine if/how various features should be integrated with existing Redux.NET classes.
• [ ] @GuillaumeSalles must be satisfied with the PR
• [ ] There should ideally be no significant objections from the always helpful @dcolthorp and @lilasquared

[cmeeren]

@dcolthorp It should be exception safe now. Calling Dispatch (on any store) or await DispatchAsync() (on AwaitableStore) will 1) bubble up the exception, and 2) make sure that the async task count is decremented.

I've added a ton of tests, check them out to see how it's used. Some tests might be unnecessary due to being pretty much being guaranteed by .NET, but much of it was copy-paste and I didn't stop to think too hard on whether all the tests were strictly needed.

[cmeeren]

I've updated the initial comment with more information.

@dcolthorp Regarding https://github.com/GuillaumeSalles/redux.NET/issues/47#issuecomment-290535579 and your mention of TakeLatest: I tried experimenting, but couldn't find a solution that was simpler than simply letting the sagas themselves handle this. I do that already in a few of my listeners.