接收多个异步操作

Question

I am reading about Rx and going through some examples. I am trying to implement this:

List<A> LIstA {get;set;}
List<B> LIstB {get;set;}
List<C> LIstC {get;set;}

private void GetItems()
{
    ListA = GetItemsA();
    ListB = GetItemsB();
    ListC = GetItemsC();
}

All this code is executed on main thread. I removed the code where main thread (UI) consumes this lists. What I would like is to fetch those items in asynchronous matter, but I need results coming in predefined sequence.

Running it in asynchronous manner is no trouble, but I am having a problem getting results in predefined sequence. So, I run the code, UI is displayed, after a few seconds ListA gets populated, then ListB , and finally ListC , only in this predefined sequence.

How to achieve this?

Answer 1

Task or async might be a better fit for this model than Rx.

Nonetheless, from what I can infer for your question, use concat to connect an observable after the previous one completes:

        Func<Action, IObservable<Unit>> fetch = 
            action => Observable.Defer(() => Observable.Start(action));

        fetch(() => A())
        .Concat(fetch(() => B()))
        .Concat(fetch(() => C()))
        .Subscribe();

Answer 2

Do this work for you?

GetItemsA().ToObservable()
    .Zip(GetItemsB().ToObservable(), (a, b) => new { a, b, })
    .Zip(GetItemsC().ToObservable(), (ab, c) => new { ab.a, ab.b, c, })
    .Subscribe(abc =>
    {
        ListA = abc.a;
        ListB = abc.b;
        ListC = abc.c;
    });

Answer 3

According to your question you have three collections of different types. Obviously one cannot concatonate three streams of different types. I think @Enigmativity's is allmost correct but in order for it to work you need change it to:

var uiScheduler = new SynchronizationContextScheduler(SynchronizationContext.Current);
ListA = new ListA();
ListB = new ListB();
ListC = new ListC();

GetItemsA().ToObservable()
.Zip(GetItemsB().ToObservable(), (a, b) => new { a, b, })
.Zip(GetItemsC().ToObservable(), (ab, c) => new { ab.a, ab.b, c, })
.ObserveOn(uiScheduler)
.Subscribe(abc =>
{
    ListA.Add(abc.a);
    ListB.Add(abc.b);
    ListC.Add(abc.c);
});

Another solution might be:

var a = Observable.Start(() => GetListA());
var b = Observable.Start(() => GetListB());
var c = Observable.Start(() => GetListC());

a.Zip(b, c, (x, y, z) => Tuple.Create(x, y, z))
    .ObserveOn(uiScheduler)
    .Subscribe(result =>
                 {
                   ListA = result.Item1;
                   ListB = result.Item2;
                   ListC = result.Item3;
                 });

I you want the collections as soon as they are created:

  a.ObserveOn(uiScheduler)
    .Do(l => ListA = l)
    .Zip(b, (la, lb) => lb)
    .ObserveOn(uiScheduler)
    .Do(l => ListB = l)
    .Zip(c, (lb, lc) => lc)
    .ObserveOn(uiScheduler)
    .Subscribe(listc => ListC = listc);

Answer 4

You could use dynamics as well ...:

void Main()
{
    var q =
    from @as in Observable.Start(() => GetItemsA())
    from bs in Observable.Start(() => GetItemsB())
    from cs in Observable.Start(() => GetItemsC())
    select @as.Cast<dynamic>().Concat(bs.Cast<dynamic>()).Concat(cs.Cast<dynamic>());   
    q.Subscribe(t => t.Dump()); 
}

// Define other methods and classes here
private IEnumerable<int> GetItemsA() {
    yield return 1;
    Thread.Sleep(500);
    yield return 2;
    yield return 3;
}
private IEnumerable<string> GetItemsB() {
    yield return "A";
    yield return "B";
    Thread.Sleep(1000);
    yield return "C";
}
private List<float> GetItemsC() {
    return new List<float> { 1.1f, 2.2f, 3.3f };
}