Question

我试图创建一个Observable，其中每个项目都是通过异步任务生成的。下一项应该通过对前一项结果的异步调用（共同递归）生成。在＆＃34;生成＆＃34;说法看起来像这样 - 除了 Generate不支持async （它也不支持初始状态的委托。

var ob = Observable.Generate(
   async () => await ProduceFirst(),        // Task<T> ProduceFirst()
   prev => Continue(prev)                   // bool Continue(T);
   async prev => await ProduceNext(prev)    // Task<T> ProduceNext(T)
   item => item
);

作为一个更具体的示例，要通过一次获取100条消息来查看ServiceBus队列中的所有消息，请按如下方式实现ProduceFirst，Continue和ProduceNext：

Task<IEnumerable<BrokeredMessage>> ProduceFirst() 
{
    const int batchSize = 100;
    return _serviceBusReceiver.PeekBatchAsync(batchSize);
}

bool Continue(IEnumerable<BrokeredMessage> prev)
{
    return prev.Any();
}

async Task<IEnumerable<BrokeredMessage>> ProduceNext(IEnumerable<BrokeredMessage> prev) 
{
    const int batchSize = 100;
    return (await _serviceBusReceiver.PeekBatchAsync(prev.Last().SequenceNumber, batchSize + 1)).Skip(1)
}

然后致电.SelectMany(i => i)上的IObservable<IEnumerable<BrokeredMessage>>将其变为IObservable<BrokeredMessage>

其中_serviceBusReceiver是接口的实例，如下所示：

public interface IServiceBusReceiver
{
    Task<IEnumerable<BrokeredMessage>> PeekBatchAsync(int batchSize);
    Task<IEnumerable<BrokeredMessage>> PeekBatchAsync(long fromSequenceNumber, int batchSize);
}

而BrokeredMessage来自https://msdn.microsoft.com/en-us/library/microsoft.servicebus.messaging.brokeredmessage.aspx

Answer 1

如果要打开自己的异步Generate函数，我建议使用递归调度而不是包装while循环。

public static IObservable<TResult> Generate<TResult>(
    Func<Task<TResult>> initialState,
    Func<TResult, bool> condition,
    Func<TResult, Task<TResult>> iterate,
    Func<TResult, TResult> resultSelector,
    IScheduler scheduler = null) 
{
  var s = scheduler ?? Scheduler.Default;

  return Observable.Create<TResult>(async obs => {
    return s.Schedule(await initialState(), async (state, self) => 
    {
      if (!condition(state))
      {
        obs.OnCompleted();
        return;
      }

      obs.OnNext(resultSelector(state));

      self(await iterate(state));

    });
  });
}

这有几个优点。首先，您可以取消此操作，使用简单的while循环无法直接取消它，事实上，在observable完成之前，您甚至不会返回订阅函数。其次，这可以让你控制每个项目的调度/异步（这使得测试变得轻而易举），这也使它更适合于库

Answer 2

在做了一些测试后，我认为这可以很好地使用内置的Rx操作符。

public static IObservable<TResult> Generate<TResult>(
    Func<Task<TResult>> initialState,
    Func<TResult, bool> condition,
    Func<TResult, Task<TResult>> iterate,
    Func<TResult, TResult> resultSelector,
    IScheduler scheduler = null) 
{
    return Observable.Create<TResult>(o =>
    {
        var current = default(TResult);
        return
            Observable
                .FromAsync(initialState)
                .Select(y => resultSelector(y))
                .Do(c => current = c)
                .Select(x =>
                    Observable
                        .While(
                            () => condition(current),
                            Observable
                                .FromAsync(() => iterate(current))
                                .Select(y => resultSelector(y))
                        .Do(c => current = c))
                        .StartWith(x))
                .Switch()
                .Where(x => condition(x))
                .ObserveOn(scheduler ?? Scheduler.Default)
                .Subscribe(o);
    });
}

我已使用以下代码测试了此代码：

bool Continue(IEnumerable<BrokeredMessage> prev)
{
    return prev.Any();
}

Task<IEnumerable<BrokeredMessage>> ProduceFirst()
{
    return
        Task.FromResult(
            EnumerableEx.Return(
                new BrokeredMessage()
                {
                    SequenceNumber = 1
                }));
}

Task<IEnumerable<BrokeredMessage>> ProduceNext(IEnumerable<BrokeredMessage> prev) 
{
    return Task.FromResult(
        prev.Last().SequenceNumber < 3
            ? EnumerableEx.Return(
                new BrokeredMessage()
                {
                    SequenceNumber = prev.Last().SequenceNumber + 1 
                })
            : Enumerable.Empty<BrokeredMessage>());
}

public class BrokeredMessage
{
    public int SequenceNumber;
}

运行此序列：

var ob = Generate(
    async () => await ProduceFirst(),
    prev => Continue(prev),
    async prev => await ProduceNext(prev),
    item => item);

我得到了这个结果：

result

我的测试代码也使用了Reactive Extension团队的Interactive Extensions - NuGet“Ix-Main”。

Answer 3

这是另一种实现方法，受到Enigmativity的answer的启发。它使用了较新的语言功能（C＃7 tuple deconstruction）。

public static IObservable<TResult> Generate<TResult>(
    Func<Task<TResult>> initialState,
    Func<TResult, bool> condition,
    Func<TResult, Task<TResult>> iterate,
    Func<TResult, TResult> resultSelector,
    IScheduler scheduler = null)
{
    return Observable.Create<TResult>(observer =>
    {
        var (isFirst, current) = (true, default(TResult));
        return Observable
            .While(() => isFirst || condition(current),
                Observable.If(() => isFirst,
                    Observable.FromAsync(ct => initialState()),
                    Observable.FromAsync(ct => iterate(current))
                )
            )
            .Do(x => (isFirst, current) = (false, x))
            .Select(x => resultSelector(x))
            .ObserveOn(scheduler ?? Scheduler.Immediate)
            .Subscribe(observer);
    });
}

Answer 4

~~我认为这可能是正确答案：~~

这不是一个好的答案。不要使用。

我是由自己的Generate创建的，它支持初始状态+迭代函数的async / await：

    public static IObservable<TResult> Generate<TResult>(
        Func<Task<TResult>> initialState,
        Func<TResult, bool> condition,
        Func<TResult, Task<TResult>> iterate,
        Func<TResult, TResult> resultSelector
        )
    {
        return Observable.Create<TResult>(async obs =>
        {
            var state = await initialState();

            while (condition(state))
            {
                var result = resultSelector(state);
                obs.OnNext(result);
                state = await iterate(state);
            }

            obs.OnCompleted();

            return System.Reactive.Disposables.Disposable.Empty;
        });
    }

不幸的是，这个似乎具有副作用，即消息的产生远远超过消费。如果观察者缓慢地处理消息，那么在我们处理其中一些消息之前，这将获取数百万条消息。不完全是我们想要的服务总线。

我将通过上述方法开展工作，或许会阅读更多内容，并在必要时发布更具体的问题。

Answer 5

我自己也有类似的问题，并且同意以下评论：

我可能违背了反应式范式的精神，但这是我目前需要的-它不应继续从队列中提取消息，直到可以对其进行处理（至少在不久的将来）。

在这种情况下，我认为Ix.NET的IAsyncEnumerable比IObservable更合适-无论是此处的问题还是任何类似的异步展开功能。原因是，每次我们迭代然后从Task中提取结果时，流控制权即调用者将与我们联系，以提取下一项或如果不满足特定条件则选择不这样做。这就像IAsyncEnumerable，而不是IObservable，后者将商品推向我们，而我们无法控制费率。

Ix.NET没有合适的AsyncEnumerable.Generate版本，因此我编写了以下内容来解决此问题。

   public static IAsyncEnumerable<TState> Generate<TState>(TState initialState, Func<TState, bool> condition, Func<TState, Task<TState>> iterate)
    {
        return AsyncEnumerable.CreateEnumerable(() =>
        {
            var started = false;
            var current = default(TState);
            return AsyncEnumerable.CreateEnumerator(async c =>
            {

                if (!started)
                {
                    started = true;
                    var conditionMet = !c.IsCancellationRequested && condition(initialState);
                    if (conditionMet) current = initialState;
                    return conditionMet;
                }
                {
                    var newVal = await iterate(current).ConfigureAwait(false);
                    var conditionMet = !c.IsCancellationRequested && condition(newVal);
                    if (conditionMet) current = newVal;
                    return conditionMet;
                }

            },
                () => current,
                () => { });
        });



    }

注意：

仅经过非常轻松的测试。
返回初始状态。
不返回失败条件的第一个TState，即使它具有完成工作以取得结果。可能会有其他版本包括那个。
我更希望摆脱condition参数，因为它是请求系统，因此是否调用MoveNext完全取决于调用方，因此condition 似乎多余。本质上，它将对TakeWhile的调用添加到功能。但是我对Ix.NET的了解还不够深，知道是否需要false的{{1}}响应才能按顺序进行到MoveNext到dispose的位置，因此，我将其包括在内。

如果需要该特定类型，

IAsyncEnumerator当然可以转换为IAsyncEnumerable。

从链式任务中观察

5 个答案: