C# RX：如何处理序列中的n个缓冲项，然后在处理下n个项之前等待t秒？

我试图找出如何处理序列中的n个缓冲项，然后等待t秒再处理下n个项

下面是我尝试使用Thread.Sleep（）做的一个粗略形式。我想避免使用Thread.Sleep（）并正确地执行它

static void Main(string[] args)
{
    var t = Observable.Range(0, 100000);

    var query = t.Buffer(20);                       

    query.ObserveOn(NewThreadScheduler.Default)
        .Subscribe(x => DoStuff(x));

    Console.WriteLine("Press ENTER to exit");
    Console.ReadLine();

}

static void DoStuff(IList<int> list)
{
    Console.WriteLine(DateTime.Now);

    foreach (var value in list)
    {
        Console.WriteLine(value);
    }

    Thread.Sleep(TimeSpan.FromSeconds(10));
}

static void Main（字符串[]args）
{
var t=可观测范围（0，100000）；
var查询=t.Buffer（20）；
query.ObserveOn（NewThreadScheduler.Default）
.认购（x=>DoStuff（x））；
控制台写入线（“按回车键退出”）；
Console.ReadLine（）；
}
静态空隙度（IList列表）
{
Console.WriteLine（DateTime.Now）；
foreach（列表中的var值）
{
控制台写入线（值）；
}
睡眠（时间跨度从秒（10））；
}

有人能帮我找到一种更有效的方法吗

谢谢

Flash

//实例化一次，我们将在闭包中多次使用它。
var delay=Observable.Empty（）.delay（TimeSpan.From毫秒（10））；
//从要处理的单个项目的来源开始。
可观测范围（0，100000）
//创建批量工作。
.缓冲器（20）
//为该批工作选择一个可观察到的，并延迟。
.Select（batch=>batch.ToObservable（）.Concat（延迟））
//将这些结合在一起，形成一个“过程、延迟、重复”的可观察状态。
.Concat（）
//订阅！
.Subscribe（Console.WriteLine）；
//确保我们等待工作完成。
//还有其他同步方式，如异步/等待。
Console.ReadLine（）；

或者，您也可以使用async/await进行同步：

static IObservable<int> delay = Observable.Empty<int>().Delay(TimeSpan.FromMilliseconds(100));

static async Task Run()
{
    await Observable.Range(0, 1000)
        .Buffer(20)
        .Select(batch => batch.ToObservable().Concat(delay))
        .Concat()
        .Do(Console.WriteLine)
        .LastOrDefaultAsync();
}

static IObservable delay=Observable.Empty（）.delay（TimeSpan.frommissions（100））；
静态异步任务运行（）
{
等待观察。范围（0，1000）
.缓冲器（20）
.Select（batch=>batch.ToObservable（）.Concat（延迟））
.Concat（）
.Do（Console.WriteLine）
.LastOrDefaultAsync（）；
}

---

这难道不是一个漂亮的把戏吗？它之所以有效，是因为OnCompleted会像OnNext一样延迟

基于Christopher的答案，如果您不想让列表元素变平，您可以：

var delay = Observable.Empty<IList<int>>().Delay(TimeSpan.FromSeconds(10));

var query = Observable.Range(0, 100000)
                      .Buffer(20)
                      .Select(batch => Observable.Return(batch).Concat(delay))
                      .Concat();

query.Subscribe(list =>
                    {
                        Console.WriteLine(DateTime.Now);

                        foreach (var value in list)
                        {
                            Console.WriteLine(value);
                        }
                    });

var delay=Observable.Empty（）.delay（TimeSpan.FromSeconds（10））；
var查询=可观察范围（0，100000）
.缓冲器（20）
.Select（批=>可观察。返回（批）。Concat（延迟））
.Concat（）；
订阅（列表=>
{
Console.WriteLine（DateTime.Now）；
foreach（列表中的var值）
{
控制台写入线（值）；
}
});

var delay = Observable.Empty<IList<int>>().Delay(TimeSpan.FromSeconds(10));

var query = Observable.Range(0, 100000)
                      .Buffer(20)
                      .Select(batch => Observable.Return(batch).Concat(delay))
                      .Concat();

query.Subscribe(list =>
                    {
                        Console.WriteLine(DateTime.Now);

                        foreach (var value in list)
                        {
                            Console.WriteLine(value);
                        }
                    });