反应性扩展缓冲订阅

Question

I am fairly new to Rx and am having trouble finding a solution to my problem. I am using Rx to commence a download through a client library. Currently it looks like:

private void DownloadStuff(string descriptor, Action<Stuff> stuffAction)
{
    this.stuffDownloader.GetStuffObservable(descriptor).Subscribe(x => stuffAction(x))
}

Where stuffDownloader is a wrapper around download logic defined in the client library. But I encountered a problem where I call DownloadStuff too much, causing many downloads, and overwhelming the system. Now what I would like to do is

private void DownloadStuff(string descriptor, Action<Stuff> stuffAction)
{
    this.stuffDownloader.GetStuffObservable(descriptor)
        .SlowSubscribe(TimeSpan.FromMilliSeconds(50))
        .Subscribe(x => stuffAction(x))
}

Where SlowSubscribe is some combination of Rx actions to only subscribe on some interval.

Normally I would just put these DownloadStuff calls on a queue and pull them off on an interval, but I've been trying to do more through Rx lately. Three solutions occur to me:

1. This functionality exists and can be done all on the subscription side.
2. This is possible but the infrastructure of the downloader is incorrect and should change (ie stuffDownloader needs to behave differently)
3. This shouldn't be done with Rx, do it another way.

It occurs to me #2 is possible by passing an IObservable of descriptors to the client library and somehow slowing how the descriptors get onto the Observable.

Answer 1

You could in theory use Rx to treat your requests as events. This way you could leverage the serializing nature of Rx to queue up downloads.

I would think that you network layer (or stuffDownloader) would do this for you, but if you want to join me for a hack....this is what I have come up with (Yeehaw!!)

1. Dont pass an Action, use Rx!! You are basically losing the error handling here and setting yourself up for weird unhandled exceptions.

private void DownloadStuff(string descriptor, Action<Stuff> stuffAction)

becomes

private IObservable<Stuff> DownloadStuff(string descriptor)

2. Now we just have one method calling another. Seems pointless. Throw away the abstraction.

3. Fix the underlying. To me the stuffDownloader is not doing it's job. Update the interface to take an IScheduler. Now you can pass it a dedicated EventLoopScheduler to enforce the serialization of the work

public IObservable<Stuff> GetStuffObservable(string descriptor, IScheduler scheduler)

4. Fix the implementation? As you want to serialize your requests (hmmmm....) you can just make the call synchronous.

private Stuff GetSync(string description)
{
    var request = (HttpWebRequest)WebRequest.Create("http://se300328:90/");
    var response =request.GetResponse();
    var stuff = MapToStuff(response);
    return stuff;
}

Now you just call that in you other method

public IObservable<Stuff> GetStuffObservable(string descriptor, ISchedulerLongRunning scheduler)
{
    return Observable.Create<Stuff>(o=>
        {
            try
            {
                var stuff = GetStuff(description);
                o.OnNext(stuff);
                o.OnCompleted();
            }
            catch(Exception ex)
            {
                o.OnError(ex);
            }
            return Disposable.Empty(); //If you want to be sync, you cant cancel!
        })
        .SubscribeOn(scheduler);
}

However, having done all of this, I am sure this is not what you really want. I would expect that there is a problem somewhere else in the system.

Another alternative is to consider using the Merge operator and it's max concurent feature?