轉換 IEnumerable <Task<T> &gt; 到 IObservable<T> 有異常處理

Question

我想將IEnumerable<Task<T>>轉換為IObservable<T> 。 我在這里找到了解決方案：

IObservable<T> ToObservable<T>(IEnumerable<Task<T>> source)
{
    return source.Select(t => t.ToObservable()).Merge();
}

對於通常的情況，這是完全可以的，但我需要處理異常，這可能會在該任務中引發......所以IObservable<T>不應該在第一次異常后死亡。

我讀到的，對於這個用例的建議是使用一些包裝器，它將攜帶實際值或錯誤。 所以我的嘗試是

IObservable<Either<T, Exception>> ToObservable<T>(IEnumerable<Task<T>> source)
{
    var subject = new Subject<Either<T, Exception>>();

    foreach (var observable in GetIntsIEnumerable().Select(t => t.ToObservable()))
    {
        observable.Subscribe(i => subject.OnNext(i), e => subject.OnNext(e));
    }

    return subject;
}

使用從本文中借用的Either<T, Exception> 。

但這也不行，因為沒有調用OnCompleted() 。 我該如何解決？ 我對 Rx 概念很陌生。

這是用於測試的完整代碼...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;

namespace Test
{
    class Program
    {
        static Task Main()
        {
            SemaphoreSlim signal = new SemaphoreSlim(0, 1);

            //GetInts1().Subscribe(
            //    i => Console.WriteLine($"OK: {i}"),
            //    e => Console.WriteLine($"ERROR: {e.Message}"),
            //    () => signal.Release());

            GetInts2().Subscribe(r => Console.WriteLine(r.Match(
                    i => $"OK: {i}",
                    e => $"ERROR: {e.Message}")),
                () => signal.Release());

            return signal.WaitAsync();
        }

        static IObservable<int> GetInts1()
        {
            return GetIntsIEnumerable().Select(t => t.ToObservable()).Merge();
        }

        static IObservable<Either<int, Exception>> GetInts2()
        {
            var subject = new Subject<Either<int, Exception>>();

            foreach (var observable in GetIntsIEnumerable().Select(t => t.ToObservable()))
            {
                observable.Subscribe(i => subject.OnNext(i), e => subject.OnNext(e));
            }

            return subject;
        }

        static IEnumerable<Task<int>> GetIntsIEnumerable()
        {
            Random rnd = new Random();

            foreach (int i in Enumerable.Range(1, 10))
            {
                yield return Task.Run(async () =>
                {
                    await Task.Delay(rnd.Next(0, 5000));

                    if (i == 6)
                        throw new ArgumentException();

                    return i;
                });
            }
        }
    }

    /// <summary>
    /// Functional data data to represent a discriminated
    /// union of two possible types.
    /// </summary>
    /// <typeparam name="TL">Type of "Left" item.</typeparam>
    /// <typeparam name="TR">Type of "Right" item.</typeparam>
    public class Either<TL, TR>
    {
        private readonly TL left;
        private readonly TR right;
        private readonly bool isLeft;

        public Either(TL left)
        {
            this.left = left;
            this.isLeft = true;
        }

        public Either(TR right)
        {
            this.right = right;
            this.isLeft = false;
        }

        public T Match<T>(Func<TL, T> leftFunc, Func<TR, T> rightFunc)
        {
            if (leftFunc == null)
            {
                throw new ArgumentNullException(nameof(leftFunc));
            }

            if (rightFunc == null)
            {
                throw new ArgumentNullException(nameof(rightFunc));
            }

            return this.isLeft ? leftFunc(this.left) : rightFunc(this.right);
        }

        /// <summary>
        /// If right value is assigned, execute an action on it.
        /// </summary>
        /// <param name="rightAction">Action to execute.</param>
        public void DoRight(Action<TR> rightAction)
        {
            if (rightAction == null)
            {
                throw new ArgumentNullException(nameof(rightAction));
            }

            if (!this.isLeft)
            {                
                rightAction(this.right);
            }
        }

        public TL LeftOrDefault() => this.Match(l => l, r => default);

        public TR RightOrDefault() => this.Match(l => default, r => r);

        public static implicit operator Either<TL, TR>(TL left) => new Either<TL, TR>(left);

        public static implicit operator Either<TL, TR>(TR right) => new Either<TL, TR>(right);
    }
}

Answer 1

有一個內置的機制來處理這樣的錯誤。 只需使用.Materialize()運算符，它將IObservable<T>更改為IObservable<Notification<T>>並允許將錯誤和完成視為正常值。

因此，作為一個例子， Observable.Return<int>(42)產生一個值42和一個完成，但Observable.Return<int>(42).Materialize()產生一個值Notification.CreateOnNext<int>(42) ，后跟值Notification.CreateOnCompleted<int>() ，后跟正常完成。

如果您有一個產生錯誤的序列，那么您實際上會得到一個值Notification.CreateOnError<T>(exception)然后是正常完成。

這一切都意味着您可以像這樣更改代碼：

IObservable<Notification<T>> ToObservable<T>(IEnumerable<Task<T>> source)
{
    return source.Select(t => t.ToObservable().Materialize()).Merge();
}

根據我的喜好，您的測試代碼有點復雜。 您永遠不需要以使用它們的方式使用SemaphoreSlim或Subject 。

我已經編寫了自己的測試代碼。

void Main()
{
    var r = new Random();

    IEnumerable<Task<int>> source =
        Enumerable
            .Range(0, 10).Select(x => Task.Factory.StartNew(() =>
    {
        Thread.Sleep(r.Next(10000));
        if (x % 3 == 0) throw new NotSupportedException($"Failed on {x}");
        return x;
    }));

    IObservable<Notification<int>> query = source.ToObservable();

    query
        .Do(x =>
        {
            if (x.Kind == NotificationKind.OnError)
            {
                Console.WriteLine(x.Exception.Message);
            }
        })
        .Where(x => x.Kind == NotificationKind.OnNext) // Only care about vales
        .Select(x => x.Value)
        .Subscribe(x => Console.WriteLine(x), () => Console.WriteLine("Done."));
}

public static class Ex
{
    public static IObservable<Notification<T>> ToObservable<T>(this IEnumerable<Task<T>> source)
    {
        return source.Select(t => t.ToObservable().Materialize()).Merge();
    }
}

該代碼的典型運行會產生：

Failed on 3
2
5
4
Failed on 0
Failed on 9
Failed on 6
7
1
8
Done.

Answer 2

Rx 庫包含一個Merge重載，可以直接有效地合並任務，而不是將每個任務轉換為中間的丟棄可觀察序列：

// Merges results from all source tasks into a single observable sequence.
public static IObservable<TSource> Merge<TSource>(
    this IObservable<Task<TSource>> sources);

您可以使用此運算符來實現ToObservable方法，如下所示：

IObservable<Either<T, Exception>> ToObservable<T>(IEnumerable<Task<T>> source)
{
    return source
        .Select(async task =>
        {
            try { return new Either<T, Exception>(await task); }
            catch (Exception ex) { return new Either<T, Exception>(ex); }
        })
        .ToObservable()
        .Merge();
}

您可以將ToObservable運算符放在Select運算符之前或之后，它沒有任何區別。

順便說一句，有一個包含Try<T>類型的簡約庫（ Try by Stephen Cleary）可用，該類型在功能上類似於Either類型，但專門用於將Exception作為第二種類型（作為Either<T, Exception> ）。 使用這個庫，你可以像這樣實現ToObservable方法：

IObservable<Try<T>> ToObservable<T>(IEnumerable<Task<T>> source)
{
    return source
        .Select(task => Try.Create(() => task))
        .ToObservable()
        .Merge();
}

這是Try.Create方法的定義：

// Executes the specified function, and wraps either the result or the exception.
public static Task<Try<T>> Create<T>(Func<Task<T>> func);