Question

我有这段代码：

var s1 = new Subject<Unit>();
var s2 = new Subject<Unit>();
var ss = s1.Merge(s2).Finally(() => Console.WriteLine("Finished!"));

ss.Subscribe(_ => Console.WriteLine("Next"));

s1.OnNext(new Unit());
s2.OnNext(new Unit());
s1.OnCompleted(); // I wish ss finished here.
s2.OnCompleted(); // Yet it does so here. =(

我使用OnError解决了我的问题（新的OperationCanceledException（）），但我想要一个更好的解决方案（必须有一个组合器吗？）。

Answer 1

当流完成时，我建议将onCompleted事件转换为onNext事件并使用var ss = s1.Merge(s2).TakeUntil(s1ors2complete)，而s1ors2complete在s1或s2结束时生成值，而不是重写Merge来完成。您也可以链接.TakeUntil(s1completes).TakeUntil(s2completes)而不是创建s1ors2complete。这种方法提供了比MergeWithCompleteOnEither扩展更好的组合，因为它可用于将“完成两个完成”操作符修改为“完成任何完成时”操作符。

至于如何将onNext事件转换为onCompleted事件，有几种方法可以做到这一点。 CompositeDisposable方法听起来是一个很好的方法，一些搜索找到了关于converting between onNext, onError, and onCompleted notifications的有趣线索。我可能会使用xs.SkipWhile(_ => true).concat(Observable.Return(True))创建一个名为ReturnTrueOnCompleted的扩展方法，然后您的合并变为：

var s1ors2complete = s1.ReturnTrueOnCompleted().Amb(s2.ReturnTrueOnCompleted());
var ss = s1.Merge(s2).TakeUntil(s1ors2complete).Finally(() => Console.WriteLine("Finished!"));

当其中一个输入流完成时，您还可以使用像automatically completes这样的运算符。

Answer 2

或者这个，这也很整洁：

public static class Ext
{
    public static IObservable<T> MergeWithCompleteOnEither<T>(this IObservable<T> source, IObservable<T> right)
    {
        return Observable.CreateWithDisposable<T>(obs =>
        {
            var compositeDisposable = new CompositeDisposable();
            var subject = new Subject<T>();

            compositeDisposable.Add(subject.Subscribe(obs));
            compositeDisposable.Add(source.Subscribe(subject));
            compositeDisposable.Add(right.Subscribe(subject));


            return compositeDisposable;

        });     
    }
}

这使用一个主题，确保在CreateWithDisposable（）中只有一个OnCompleted被推送给观察者;

Answer 3

假设您不需要任何一个流的输出，您可以使用Amb结合来自Materialize的一些魔法：

var s1 = new Subject<Unit>();
var s2 = new Subject<Unit>();

var ss = Observable.Amb(
        s1.Materialize().Where(x => x.Kind == NotificationKind.OnCompleted), 
        s2.Materialize().Where(x => x.Kind == NotificationKind.OnCompleted)
    )
    .Finally(() => Console.WriteLine("Finished!"));

ss.Subscribe(_ => Console.WriteLine("Next"));

s1.OnNext(new Unit());
s2.OnNext(new Unit());

s1.OnCompleted(); // ss will finish here and s2 will be unsubscribed from

如果您需要这些值，可以对这两个主题使用Do。

Answer 4

试试这个：

public static class Ext
{
    public static IObservable<T> MergeWithCompleteOnEither<T>(this IObservable<T> source, IObservable<T> right)
    {
        var completed = Observable.Throw<T>(new StreamCompletedException());

        return 
            source.Concat(completed)
            .Merge(right.Concat(completed))
            .Catch((StreamCompletedException ex) => Observable.Empty<T>());

    }

    private sealed class StreamCompletedException : Exception
    {
    }
}

这样做会连接一个IObservable，它会在源或源完成时抛出异常。然后，我们可以使用Catch扩展方法返回一个空的Observable，以便在完成时自动完成流。

如何合并两个Observable，以便在任何Observable完成时结果完成？

4 个答案: