使用Rx构建一个Observable Repository

Question

I'm working in the common scenario whereby I'd like to access a subset of a repository and not worry about having to keep it updated eg 'get all orders whose price is greater than 10'. I have implemented a solution but have two issues with it (listed at the end).

A subset of a repository can be achieved with something equivalent to

var expensiveOrders = Repository.GetOrders().Where(o => o.Price > 10);

But this is an IEnumerable and will not be updated when the original collection is updated. I could add handlers for CollectionChanged , but what if we want to access a further subset?

var expensiveOrdersFromBob = expensiveOrders.Where(o => o.Name == Bob);

We'd have to wire up a collection-changed for this one as well. The concept of live updates led me to thinking of Rx, so I set about to build an ObservableCache which contains both the ObservableCollection of items that auto-updates itself, and an RX stream for notification. (The stream is also what updates the cache under the hood.)

class ObservableCache<T> : IObservableCache<T>
{
    private readonly ObservableCollection<T> _cache;
    private readonly IObservable<Tuple<T, CRUDOperationType>> _updates;

    public ObservableCache(IEnumerable<T> initialCache
       , IObservable<Tuple<T, CRUDOperationType>> currentStream, Func<T, bool> filter)
        {
          _cache = new ObservableCollection<T>(initialCache.Where(filter));
          _updates = currentStream.Where(tuple => filter(tuple.Item1));
          _updates.Subscribe(ProcessUpdate);
        }

    private void ProcessUpdate(Tuple<T, CRUDOperationType> update)
    {
        var item = update.Item1;
        lock (_cache)
        {
            switch (update.Item2)
            {
                case CRUDOperationType.Create:
                    _cache.Add(item);
                    break;
                case CRUDOperationType.Delete:
                    _cache.Remove(item);
                    break;
                case CRUDOperationType.Replace:
                case CRUDOperationType.Update:
                    _cache.Remove(item); // ToDo: implement some key-based equality
                    _cache.Add(item);
                    break;
            }
        }
    }

    public ObservableCollection<T> Cache
    {
        get { return _cache; }
    }

    public IObservable<T> Updates
    {
        get { return _updates.Select(tuple => tuple.Item1); }
    }

    public IObservableCache<T> Where(Func<T, bool> predicate)
    {
        return new ObservableCache<T>(_cache, _updates, predicate);
    }
}

You can then use it like this:

var expensiveOrders = new ObservableCache<Order>(_orders
                                                 , updateStream
                                                 , o => o.Price > 10);
expensiveOrders.Updates.Subscribe
     (o => Console.WriteLine("Got new expensive order: " + o));
_observableBoundToSomeCtrl = expensiveOrders.Cache;

var expensiveOrdersFromBob = expensiveOrders
                             .Where(o => o.Name == "Bob");
expensiveOrdersFromBob.Updates.Subscribe
         (o => Console.WriteLine("Got new expensive order from Bob: " + o));
_observableBoundToSomeOtherCtrl = expensiveOrdersFromBob.Cache;

And so forth, the idea being that you can keep projecting the cache into narrower and narrower subsets and never have to worry about it being out of sync. So what is my problem then?

1. I'm wondering whether I can do away with the CRUD stuff by having RX intrinsically update the collections. Maybe 'project' the updates with a Select, or something like that?
2. There is a race condition intrinsic to the repository-with-update pattern, in that I might miss some updates while I'm constructing the new cache. I think I need some sort of sequencing, but that would mean having all my T objects implement an ISequenceableItem interface. Is there any better way to do this? RX is great because it handles all the threading for you. I'd like to leverage that.

Answer 1

http://github.com/wasabii/OLinq上的OLinq项目是为这种反应性更新而设计的，我认为ObservableView就是你所追求的。

Answer 2

Have a look at these two projects which achieve what you want albeit by different means:

https://github.com/RolandPheasant/DynamicData

https://bitbucket.org/mendelmonteiro/reactivetables [disclaimer: this is my project]

Answer 3

Suppose you have a definition like this:

class SetOp<T>
{
    public T Value { get; private set; }
    public bool Include { get; private set; }
    public SetOp(T value, bool include)
    {
        Value = value;
        Include = include;
    }
}

Using Observable.Scan and System.Collections.Immutable you can do something like this:

IObservable<SetOp<int>> ops = ...;
IImmutableSet<int> empty = ImmutableSortedSet<int>.Empty;
var observableSet = ops
    .Scan(empty, (s, op) => op.Include ? s.Add(op.Value) : s.Remove(op.Value))
    .StartWith(empty);

Using the immutable collection type is the key trick here: any observer of the observableSet can do whatever it wants with the values that are pushed at it, because they are immutable. Add it is efficient because it reuses the majority of the set data structure between consecutive values.

Here is an example of an ops stream and the corresponding observableSet .

ops       observableSet
--------  ------------------
          {}
Add 7     {7}
Add 4     {4,7}
Add 5     {4,5,7}
Add 6     {4,5,6,7}
Remove 5  {4,6,7}
Add 8     {4,6,7,8}
Remove 4  {6,7,8}

Answer 4

You should not need to lock _cache within ProcessUpdate . If your source observable currentStream is honoring Rx Guidelines you are guaranteed to only be within a single call to OnNext at a time. In otherwords, you will not receive another value from the stream while you are still processing the previous value.

The only reliable way to solve your race condition is to make sure you create the cache before the updateStream starts producing data.

You may want to take a look at Extensions for Reactive Extensions (Rxx) . I believe Dave has built a number of utilities for binding UI controls to observable data. Documentation is sparse. I don't know if there is anything there for what you are doing.