C# 被动。主体使onNext等待上一个onNext操作

我正在尝试实现observable，等待

onNext

操作完成，然后再继续执行下一个操作。我发现工作的唯一方法是使用

信号量lim

。无需使用

信号量lim

，Reactive是否有办法做到这一点？我找不到

 SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1,1);
  subject.Window(() => subject.Throttle(TimeSpan.FromMilliseconds(500)))
            .SelectMany(c => c.ToList())
            .Subscribe(async x =>
                {
                    await _semaphoreSlim.WaitAsync();
                    try
                    {
                        //await Async code here
                    }
                    finally
                    {
                        _semaphoreSlim.Release();
                    }
                });

---

首先，我创建了一个示例

Media\u Load\u Async

，模拟您正在做的事情

static int max = 5;
static Random random = new Random();
static TimeSpan[] delays = Enumerable.Range(0, max).Select(x => TimeSpan.FromSeconds(random.Next(5) + 2)).ToArray();

async Task<Unit> Media_Load_Async(int index, TimeSpan delay)
{
    Console.WriteLine($"Start {index} - {delay}");
    await Task.Delay(delay);
    Console.WriteLine($"End {index}");
    return Unit.Default;
}

如果我输入你的

SemaporeSlim

代码，我会得到你想要的：

SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);
Observable
    .Range(0, max)
    .Subscribe(async x =>
    {
        await _semaphoreSlim.WaitAsync();
        try
        {
            await Media_Load_Async(x, delays[x]);
        }
        finally
        {
            _semaphoreSlim.Release();
        }
    });

接下来，如果我将对

Media\u Load\u Async

的调用移动到查询本身内部，那么我将回到原始问题：

Observable
    .Range(0, max)
    .SelectMany(x => Observable.FromAsync(() => Media_Load_Async(x, delays[x])))
    .Subscribe();

但是如果我将

SelectMany

更改为

Select

/

Concat

对，那么我就可以在没有

信号量lim的情况下得到您想要的：

Observable
    .Range(0, max)
    .Select(x => Observable.FromAsync(() => Media_Load_Async(x, delays[x])))
    .Concat()
    .Subscribe();

看看这些：。核心接收接口是同步的。已实现具有异步接口的Rx的替代版本（），但是。我正在尝试您的解决方案，但不幸的是，Observable.FromAsync给我带来了麻烦，因为它在另一个SynchronizationContext上被调用。我需要在UI线程上进行观察。因此，您提出的解决方案进行了一些调整。我将在这里留下代码，以防：subject.Window（（）=>subject.Throttle（TimeSpan.frommissions（500））.SelectMany（c=>c.ToList（））.Select（c=>（reloadMap:c.Any（z=>z.reloadMap），c.LastOrDefault（z=>z.rowIndex.HasValue）.rowIndex））.Select（x=>Observable.fromsync（（）=>（Task）this.Invoke）（新的MethodInvoker（（）=>x.rowIndex.HasValue？媒体加载异步（x.rowIndex.Value）：Task.CompletedTask）））.Concat（）.Subscribe（）；
Start 0 - 00:00:04
End 0
Start 1 - 00:00:03
End 1
Start 2 - 00:00:06
End 2
Start 3 - 00:00:04
End 3
Start 4 - 00:00:03
End 4

Observable
    .Range(0, max)
    .SelectMany(x => Observable.FromAsync(() => Media_Load_Async(x, delays[x])))
    .Subscribe();

Start 0 - 00:00:06
Start 1 - 00:00:02
Start 2 - 00:00:06
Start 3 - 00:00:05
Start 4 - 00:00:02
End 4
End 1
End 3
End 0
End 2

Observable
    .Range(0, max)
    .Select(x => Observable.FromAsync(() => Media_Load_Async(x, delays[x])))
    .Concat()
    .Subscribe();

Start 0 - 00:00:04
End 0
Start 1 - 00:00:05
End 1
Start 2 - 00:00:02
End 2
Start 3 - 00:00:06
End 3
Start 4 - 00:00:06
End 4