C# 如何使用列表阻止ToObservable<>；？

我第一次尝试RX，我有几个问题

1） 有没有更好的方法来实现集合的异步

2） 我需要在线程上阻塞，直到所有异步任务完成，我该怎么做

class Program
{

    internal class MyClass
    {
        private readonly List<int> _myData = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        private readonly Random random = new Random();

        public int DoSomething(int j)
        {
            int i = random.Next(j * 1000) - (j * 200);
            i = i < 0 ? 1000 : i;
            Thread.Sleep(i);
            Console.WriteLine(j);
            return j;
        }

        public IObservable<int> DoSomethingAsync(int j)
        {
            return Observable.CreateWithDisposable<int>(
                o => Observable.ToAsync<int, int>(DoSomething)(j).Subscribe(o)
                );
        }

        public void CreateTasks()
        {
            _myData.ToObservable(Scheduler.NewThread).Subscribe(
            onNext: (i) => DoSomethingAsync(i).Subscribe(),
            onCompleted: () => Console.WriteLine("Completed")
                );
        }
    }

    static void Main(string[] args)
    {
        MyClass test = new MyClass();

        test.CreateTasks();

        Console.ReadKey(); 
    } 
}

类程序
{
内部类MyClass
{
私有只读列表_myData=new List（）{1,2,3,4,5,6,7,8,9,10}；
private readonly Random=new Random（）；
公共int剂量测量（int j）
{
int i=随机。下一个（j*1000）-（j*200）；
i=i<0？1000:i；
睡眠（i）；
控制台写入线（j）；
返回j；
}
公共IObservable DoSomethingAsync（int j）
{
返回可观察的.CreateWithDisposable(
o=>observeable.ToAsync（DoSomething）（j）.Subscribe（o）
);
}
public void CreateTasks（）
{
_ToObservable（Scheduler.NewThread）.Subscribe(
onNext:（i）=>DoSomethingAsync（i）.Subscribe（），
未完成：（）=>Console.WriteLine（“已完成”）
);
}
}
静态void Main（字符串[]参数）
{
MyClass测试=新的MyClass（）；
test.CreateTasks（）；
Console.ReadKey（）；
} 
}

（注意：我知道我可以使用Observable.Range作为Int列表，但我的列表在实际程序中不是Int类型）。

我可能会尝试

public void CreateTasks()                
{                       
    _myData.ToObservable(Scheduler.NewThread)
        .SelectMany(i => Observable.Start(() => DoSomething(i)))
        .Subscribe(j => Console.WriteLine("j is {0}", j), 
                  () => Console.WriteLine("Completed"));       
} 

首先，我修改了DoSomethingAsync，使其使用

Observable.Start

。Observable.Start将异步运行

DoSomething

方法，并在方法完成时通过

IObservable.OnNext

返回值

---

然后CreateTasks方法像以前一样在集合中的每个项上运行，但将每个值输入到一个

SelectMany

，该方法继续调用DoSomethingAsync方法。结果是，当它们全部完成时，对于每个完成的DoSomethingAsync调用，您将收到一个

OnNext

，以及一个

OnComplete

。

很酷，这很好，我该如何使用热的可观察对象（我注意到在我的示例中，它在没有延迟的情况下工作正常）？@MrJavaGuy-我的坏。。。不确定，但我认为在工作中，我有一个较旧的版本，其中Start返回一个热的可观测值。刚刚测试了一个更新的版本，它返回了一个冷的可观察的。我想现在把DoSomethingAsync全部去掉会更干净。请参阅最新编辑。