如何从多个DBContext创建可观察的热RX

Question

DBContexts are short lived, created and destroyed with every request. I have a number of tasks that I'd like to perform prior to and post save and I'd like to handle these with some sort of eventing model. I'm wondering in RX is the right route.

Is there some way of creating a singleton "hub" then causing my DBContext to raise BeforeChange (SavingChanges event) and post save (no applicable event) Observables and "push" them into the long lived hub.

In effect I'd like to do this in my "hub" singleton

    public IObservable<EventPattern<EventArgs>> Saves = new Subject<EventPattern<EventArgs>>();

    public void AttachContext(DbContext context)
    {
        Saves = Observable.FromEventPattern<EventArgs>(((IObjectContextAdapter)context).ObjectContext, "SavingChanges");
    }

but in such a way that AttachContext simply feed its generated observable into the exisitng Saves observabe, rather than replacing it (and all of its subscriptions)?

Answer 1

Yes. Use a nested observable + merge:

private readonly Subject<IObservable<EventPattern<EventArgs>> _contexts = new Subject<IObservable<EventPattern<EventArgs>>();

private readonly IObservable<EventPattern<EventArgs>> _saves = _contexts.Merge();

public IObservable<EventPattern<EventArgs>> Saves { get { return _saves; } }

public void AttachContext(DbContext context)
{
    _contexts.OnNext(Observable.FromEventPattern<EventArgs>(((IObjectContextAdapter)context).ObjectContext, "SavingChanges"));
}

The only problem with this is that the list of contexts being observed will grow unbounded since the Observable.FromEventPattern never completes. So this is effectively a memory leak as coded.

If you know that the db context will be used for a single save, then you could add a .FirstAsync() to the end of the call to Observable.FromEventPattern . This will cause your subject to stop watching the context once it has seen an event from it.

This still suffers from the problem that maybe a context is attached but its Save is never performed (due to logic, or an error or whatever).

The only way I know to resolve the problem is to change AttachContext to return an IDisposable that the caller must use when they want to detach the context:

public IDisposable AttachContext(DbContext context)
{
    var detachSignal = new AsyncSubject<Unit>();
    var disposable = Disposable.Create(() =>
    {
        detachSignal.OnNext(Unit.Default);
        detachSignal.OnCompleted();
    });
    var events = Observable.FromEventPattern<EventArgs>(((IObjectContextAdapter)context).ObjectContext, "SavingChanges");

    _contexts.OnNext(events.TakeUntil(detachSignal));
    return disposable;
}