Question

如果发生错误，有没有办法让一个可观察序列继续执行序列中的下一个元素？从this post 看起来你需要在Catch（）中指定一个新的可观察序列来恢复执行，但是如果你需要继续处理序列中的下一个元素呢？有没有办法实现这个目标？

更新：方案如下：我有一堆我需要处理的元素。处理由一系列步骤组成。我有将这些步骤分解为我想要编写的任务。我遵循ToObservable（）发布的here指南按任务转换为可观察的构图。所以我基本上都是这样做的 -

foreach(element in collection)
{
   var result = from aResult in DoAAsync(element).ToObservable() 
         from bResult in DoBAsync(aResult).ToObservable() 
         from cResult in DoCAsync(bResult).ToObservable() 
         select cResult;
   result.subscribe( register on next and error handlers here)
 }

或者我可以这样：

var result = 
        from element in collection.ToObservable() 
        from aResult in DoAAsync(element).ToObservable() 
         from bResult in DoBAsync(aResult).ToObservable() 
         from cResult in DoCAsync(bResult).ToObservable() 
         select cResult;

这里继续处理其他元素的最佳方法是什么，即使让我们说处理其中一个元素抛出异常。我希望能够记录错误并理想地继续前进。

Answer 1

James＆amp;理查德提出了一些好处，但我认为他们没有给你解决问题的最佳方法。

詹姆斯建议使用.Catch(Observable.Never<Unit>())。当他说“将......允许流继续”时他错了，因为一旦你遇到异常，流就必须结束 - 这就是理查德在提到观察者与观察者之间的契约时所指出的。

此外，以这种方式使用Never将导致您的观察者永远不会完成。

简短的回答是.Catch(Observable.Empty<Unit>())是将序列从以错误结尾的序列更改为以完成结束的序列的正确方法。

你已经找到了使用SelectMany来处理源集合的每个值的正确想法，这样你就可以捕获每个异常，但是你会遇到一些问题。

您正在使用任务（TPL）将函数调用转换为可观察对象。这会强制您的observable使用任务池线程，这意味着SelectMany语句可能会以非确定性顺序生成值。

此外，您隐藏了处理数据的实际调用，使重构和维护更加困难。

我认为你最好创建一个允许跳过异常的扩展方法。这是：

public static IObservable<R> SelectAndSkipOnException<T, R>(
    this IObservable<T> source, Func<T, R> selector)
{
    return
        source
            .Select(t =>
                Observable.Start(() => selector(t)).Catch(Observable.Empty<R>()))
            .Merge();
}

使用此方法，您现在可以简单地执行此操作：

var result =
    collection.ToObservable()
        .SelectAndSkipOnException(t =>
        {
            var a = DoA(t);
            var b = DoB(a);
            var c = DoC(b);
            return c;
        });

此代码更简单，但它隐藏了异常。如果你想在继续你的序列的同时坚持异常，那么你需要做一些额外的乐趣。向Materialize扩展方法添加几个重载可以防止错误。

public static IObservable<Notification<R>> Materialize<T, R>(
    this IObservable<T> source, Func<T, R> selector)
{
    return source.Select(t => Notification.CreateOnNext(t)).Materialize(selector);
}

public static IObservable<Notification<R>> Materialize<T, R>(
    this IObservable<Notification<T>> source, Func<T, R> selector)
{
    Func<Notification<T>, Notification<R>> f = nt =>
    {
        if (nt.Kind == NotificationKind.OnNext)
        {
            try
            {
                return Notification.CreateOnNext<R>(selector(nt.Value));
            }
            catch (Exception ex)
            {
                ex.Data["Value"] = nt.Value;
                ex.Data["Selector"] = selector;
                return Notification.CreateOnError<R>(ex);
            }
        }
        else
        {
            if (nt.Kind == NotificationKind.OnError)
            {
                return Notification.CreateOnError<R>(nt.Exception);
            }
            else
            {
                return Notification.CreateOnCompleted<R>();
            }
        }
    };
    return source.Select(nt => f(nt));
}

这些方法允许你写这个：

var result =
    collection
        .ToObservable()
        .Materialize(t =>
        {
            var a = DoA(t);
            var b = DoB(a);
            var c = DoC(b);
            return c;
        })
        .Do(nt =>
        {
            if (nt.Kind == NotificationKind.OnError)
            {
                /* Process the error in `nt.Exception` */
            }
        })
        .Where(nt => nt.Kind != NotificationKind.OnError)
        .Dematerialize();

您甚至可以链接这些Materialize方法并使用ex.Data["Value"]＆amp; ex.Data["Selector"]获取抛出错误的值和选择器函数。

我希望这会有所帮助。

Answer 2

IObservable和IObserver之间的合同为OnNext*(OnCompelted|OnError)?，即使不是来源，也会得到所有运营商的支持。

您唯一的选择是使用Retry重新订阅来源，但如果来源为每个描述返回IObservable 实例，您将看不到任何新内容值。

您能提供有关您的方案的更多信息吗？也许有另一种方式来看待它。

修改：根据您的最新反馈，您只需要Catch：

var result = 
    from element in collection.ToObservable() 
    from aResult in DoAAsync(element).ToObservable().Log().Catch(Observable.Empty<TA>())
    from bResult in DoBAsync(aResult).ToObservable().Log().Catch(Observable.Empty<TB>()) 
    from cResult in DoCAsync(bResult).ToObservable().Log().Catch(Observable.Empty<TC>())
    select cResult;

这会替换Empty的错误，该错误不会触发下一个序列（因为它在引擎盖下使用SelectMany。

使用Rx处理可观察序列中的错误

2 个答案: