C# 在所有订阅结束时获取

我正在创建几个订阅

我需要检测它们（全部）何时完成，以便执行操作

private IList<IDisposable> subscriptions = new List<IDisposable>();

private void CreateSubscriptions(IEnumerable<int> integers)
{
    if (this.subscriptions.Any())
        foreach (IDisposable subscription in this.subscriptions)
            subscription.Dispose();

    this.subscriptions.Clear();

    for (int i = 0; i < 50; i++)
    {    
        this.subscriptions.Add(
            Observable.Create<int>(
                observer =>
                {
                    foreach (int i in integers)
                        observer.OnNext(i);

                    observer.Completed();

                    return System.Reactive.Disposables.Disposable.Empty;
                }
            )
            .SubscribeOn(System.Reactive.Concurrency.TaskPoolScheduler.Default)
            .ObserveOn(this.fuasTileControl)
            .Subscribe(
                // action
            );
    }
}

private IList subscriptions=new List（）；
私有void CreateSubscriptions（IEnumerable整数）
{
if（this.subscriptions.Any（））
foreach（此.subscriptions中的IDisposable订阅）
subscription.Dispose（）；
this.subscriptions.Clear（）；
对于（int i=0；i<50；i++）
{    
此文件为.subscriptions.Add(
可观察。创建(
观察员=>
{
foreach（整数中的整数i）
观察员OnNext（一）；
observer.Completed（）；
返回系统。反应性。一次性。一次性。空；
}
)
.SubscribeOn（System.Reactive.Concurrency.TaskPoolScheduler.Default）
.ObserveOn（此为fuasTileControl）
.订阅(
//行动
);
}
}

如您所见，我正在创建50个可观察对象，通知

IEnumerable

的下一个值。这是一个示例代码

我需要获取所有订阅结束（完成）的时间，以便执行操作

private IList<IDisposable> subscriptions = new List<IDisposable>();

private void CreateSubscriptions(IEnumerable<int> integers)
{
    if (this.subscriptions.Any())
        foreach (IDisposable subscription in this.subscriptions)
            subscription.Dispose();

    this.subscriptions.Clear();

    for (int i = 0; i < 50; i++)
    {    
        this.subscriptions.Add(
            Observable.Create<int>(
                observer =>
                {
                    foreach (int i in integers)
                        observer.OnNext(i);

                    observer.Completed();

                    return System.Reactive.Disposables.Disposable.Empty;
                }
            )
            .SubscribeOn(System.Reactive.Concurrency.TaskPoolScheduler.Default)
            .ObserveOn(this.fuasTileControl)
            .Subscribe(
                // action
            );
    }
}

---

有什么想法吗？

可能有更好的选择，但我知道的一个是使用

Merge

操作符。请参阅

然后，您可以订阅此可观察项。如果需要阻塞解决方案，您可以使用

Wait（）

我还对其他解决方案感兴趣

void Main()
{
    var sequence = CreateSubscriptions( new[] {1,5,6});

    sequence.Subscribe((i) => {}, () => { Console.WriteLine("all ready"); });

    //sequence.Wait();
    //Console.WriteLine("all ready");
}

private IList<IDisposable> subscriptions = new List<IDisposable>();

private IObservable<int> CreateSubscriptions(IEnumerable<int> integers)
{
    if (this.subscriptions.Any())
        foreach (IDisposable subscription in this.subscriptions)
            subscription.Dispose();

    this.subscriptions.Clear();
    var sequences = new List<IObservable<int>>();

    for (int ix = 0; ix < 5; ix++)
    {    
        var sequence = Observable.Create<int>(
                observer =>
                {
                    foreach (int i in integers)
                        observer.OnNext(i);

                    observer.OnCompleted();

                    return System.Reactive.Disposables.Disposable.Empty;
                }
            );
        sequences.Add(sequence);    
        this.subscriptions.Add(sequence.Subscribe(nr => 
        {  
            Console.WriteLine(nr); 
        }));
    }

    return Observable.Merge(sequences);
}

void Main（）
{
var sequence=CreateSubscriptions（新[]{1,5,6}）；
sequence.Subscribe（（i）=>{}，（）=>{Console.WriteLine（“全部就绪”）；}）；
//sequence.Wait（）；
//控制台。WriteLine（“准备就绪”）；
}
私有IList订阅=新列表（）；
私有IObservable CreateSubscriptions（IEnumerable整数）
{
if（this.subscriptions.Any（））
foreach（此.subscriptions中的IDisposable订阅）
subscription.Dispose（）；
this.subscriptions.Clear（）；
var序列=新列表（）；
对于（int-ix=0；ix<5；ix++）
{    
变量序列=可观察。创建(
观察员=>
{
foreach（整数中的整数i）
观察员OnNext（一）；
observer.OnCompleted（）；
返回系统。反应性。一次性。一次性。空；
}
);
顺序。添加（顺序）；
this.subscriptions.Add（sequence.subscripte）（nr=>
{  
控制台写入线（nr）；
}));
}
返回可观察。合并（序列）；
}

---

我也做了一些小的修改以使它能够编译。

可能有更好的选择，但我知道的一个是使用

合并操作符。请参阅

然后，您可以订阅此可观察项。如果需要阻塞解决方案，您可以使用
Wait（）

我还对其他解决方案感兴趣

void Main()
{
    var sequence = CreateSubscriptions( new[] {1,5,6});

    sequence.Subscribe((i) => {}, () => { Console.WriteLine("all ready"); });

    //sequence.Wait();
    //Console.WriteLine("all ready");
}

private IList<IDisposable> subscriptions = new List<IDisposable>();

private IObservable<int> CreateSubscriptions(IEnumerable<int> integers)
{
    if (this.subscriptions.Any())
        foreach (IDisposable subscription in this.subscriptions)
            subscription.Dispose();

    this.subscriptions.Clear();
    var sequences = new List<IObservable<int>>();

    for (int ix = 0; ix < 5; ix++)
    {    
        var sequence = Observable.Create<int>(
                observer =>
                {
                    foreach (int i in integers)
                        observer.OnNext(i);

                    observer.OnCompleted();

                    return System.Reactive.Disposables.Disposable.Empty;
                }
            );
        sequences.Add(sequence);    
        this.subscriptions.Add(sequence.Subscribe(nr => 
        {  
            Console.WriteLine(nr); 
        }));
    }

    return Observable.Merge(sequences);
}

void Main（）
{
var sequence=CreateSubscriptions（新[]{1,5,6}）；
sequence.Subscribe（（i）=>{}，（）=>{Console.WriteLine（“全部就绪”）；}）；
//sequence.Wait（）；
//控制台。WriteLine（“准备就绪”）；
}
私有IList订阅=新列表（）；
私有IObservable CreateSubscriptions（IEnumerable整数）
{
if（this.subscriptions.Any（））
foreach（此.subscriptions中的IDisposable订阅）
subscription.Dispose（）；
this.subscriptions.Clear（）；
var序列=新列表（）；
对于（int-ix=0；ix<5；ix++）
{    
变量序列=可观察。创建(
观察员=>
{
foreach（整数中的整数i）
观察员OnNext（一）；
observer.OnCompleted（）；
返回系统。反应性。一次性。一次性。空；
}
);
顺序。添加（顺序）；
this.subscriptions.Add（sequence.subscripte）（nr=>
{  
控制台写入线（nr）；
}));
}
返回可观察。合并（序列）；
}

我也做了一些小的修改以使它能够编译。
有点迂腐，但正确的答案是这是不可能的：订阅由一个
IDisposable
表示，它没有提供外部方法来检测它何时终止（除了直接导致终止）。更准确地说，考虑到您在上面演示的填充
IList订阅的功能
，当所有订阅都被释放时，没有任何机制来执行/订阅

然而，有一种方法可以对一组可观测数据（由
IObservable
表示）以及完成这些数据时采取行动

给定
IEnumerable observatives
或
IOobservatable observatives
，以下操作将起作用：

observables
    .Merge()
    .Subscribe(
        item => { /*onNext handler*/ }, 
        e =>    { /*onError handler*/ }, 
        () =>   { /* onCompleted handler */});

作为
未完成的
处理程序，您可能希望执行任何您想要的操作。
有点迂腐，但正确的答案是这是不可能的：订阅由
IDisposable
表示，它不提供外部方法来检测何时终止（除了直接导致终止）。更准确地说，考虑到您在上面演示的填充
IList订阅的功能
，当所有订阅都被释放时，没有任何机制来执行/订阅

然而，有一种方法可以对一组可观测数据（由
IObservable
表示）以及完成这些数据时采取行动

给定
IEnumerable observatives
或
IOobservatable observatives
，以下操作将起作用：

observables
    .Merge()
    .Subscribe(
        item => { /*onNext handler*/ }, 
        e =>    { /*onError handler*/ }, 
        () =>   { /* onCompleted handler */});

当您发现自己在做
返回一次性.Empty；
时，您可能希望将您想要的任何操作作为
完成的
处理程序。
当您发现自己在做
返回一次性.Empty；
时，您正在做一些错误的事情。尽量避免这样做，因为这会中断查询。当您发现自己在做
返回一次性.Empty；
时，您正在做som