C# 系统中递归调度的功能优势是什么？

我现在正在阅读，我对从我的反应性代码中剥离

主题
非常感兴趣。我开始理解如何封装序列生成，以便更好地推理给定序列。我读了一些问题，最后读到了关于日程安排的内容。特别令人感兴趣的是递归调度，使用
调度（这是调度程序调度器，操作）
重载-

这本书开始在一些领域展示它的时代，我看到的最大的一点是，它从未将它的技术与使用
任务
和
异步/等待
语言功能可以实现的替代方案进行比较。我总是觉得我可以通过忽略书本上的建议和使用异步玩具来编写更少的代码，但是我的内心深处一直在抱怨我太懒，没有正确地学习模式

有了这些，我的问题来了。如果我想每隔一段时间安排一个序列，支持取消并在后台线程上执行工作，我可以这样做：

    static void Main(string[] args)
    {
        var sequence = Observable.Create<object>(o =>
        {
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            DoWerk(o, cancellationTokenSource);

            return cancellationTokenSource.Cancel;
        });

        sequence.Subscribe(p => Console.Write(p));

        Console.ReadLine();
    }

    private static async void DoWerk(IObserver<object> o, CancellationTokenSource cancellationTokenSource)
    {
        string message =  "hello world!";
        for (int i = 0; i < message.Length; i++)
        {
            await Task.Delay(250, cancellationTokenSource.Token);
            o.OnNext(message[i]);

            if (cancellationTokenSource.IsCancellationRequested)
            {
                break;
            }
        }

        o.OnCompleted();
    }

static void Main（字符串[]args）
{
变量序列=可观察。创建（o=>
{
CancellationTokenSource CancellationTokenSource=新的CancellationTokenSource（）；
DoWerk（o，cancellationTokenSource）；
返回cancellationTokenSource。取消；
});
sequence.Subscribe（p=>Console.Write（p））；
Console.ReadLine（）；
}
专用静态异步void DoWerk（IObserver o，CancellationTokenSource CancellationTokenSource）
{
string message=“你好，世界！”；
for（int i=0；i

请注意，使用
async void
创建并发，而无需使用
Task.Run（）
显式借用线程池线程<但是，code>wait Task.Delay（）
将仅执行此操作，但不会长期租用线程

这里的限制和陷阱是什么？您可能喜欢使用递归调度的原因是什么？
我个人不会使用
等待任务.Delay（250，cancellationTokenSource.Token）作为减慢循环速度的一种方法。它比Thread.Sleep（250）
要好，但对我来说它仍然是代码的味道

我认为您应该使用内置操作符，而不是像这样滚动您自己的解决方案

您需要的操作员是最强大的操作员之一，但经常被忽略。尝试
可观察。生成
。他是如何：

static void Main(string[] args)
{
    IObservable<char> sequence = Observable.Create<char>(o =>
    {
        string message =  "hello world!";
        return
            Observable
                .Generate(
                    0,
                    n => n < message.Length,
                    n => n + 1,
                    n => message[n],
                    n => TimeSpan.FromMilliseconds(250.0))
                .Subscribe(o);
    });

    using (sequence.Subscribe(p => Console.Write(p)))
    {
        Console.ReadLine();
    }
}

最后，在你的问题中，日程安排并没有什么“递归的”。你这是什么意思


我终于明白你在看什么了。我在问题中漏掉了

下面是使用递归调度的示例：

IObservable<char> sequence = Observable.Create<char>(o =>
{
    string message = "hello world!";
    return Scheduler.Default.Schedule<string>(message, TimeSpan.FromMilliseconds(250.0), (state, schedule) =>
    {
        if (!String.IsNullOrEmpty(state))
        {
            o.OnNext(state[0]);
            schedule(state.Substring(1), TimeSpan.FromMilliseconds(250.0));
        }
        else
        {
            o.OnCompleted();
        }
    });
});

IObservable sequence=Observable.Create（o=>
{
string message=“你好，世界！”；
返回Scheduler.Default.Schedule（消息，TimeSpan.From毫秒（250.0），（状态，Schedule）=>
{
如果（！String.IsNullOrEmpty（状态））
{
o、 OnNext（state[0]）；
计划（状态子字符串（1），时间跨度从毫秒（250.0））；
}
其他的
{
o、 未完成（）；
}
});
});
我个人不会使用
等待任务延迟（250，cancellationTokenSource.Token）作为减慢循环速度的一种方法。它比Thread.Sleep（250）
要好，但对我来说它仍然是代码的味道

我认为您应该使用内置操作符，而不是像这样滚动您自己的解决方案

您需要的操作员是最强大的操作员之一，但经常被忽略。尝试
可观察。生成
。他是如何：

static void Main(string[] args)
{
    IObservable<char> sequence = Observable.Create<char>(o =>
    {
        string message =  "hello world!";
        return
            Observable
                .Generate(
                    0,
                    n => n < message.Length,
                    n => n + 1,
                    n => message[n],
                    n => TimeSpan.FromMilliseconds(250.0))
                .Subscribe(o);
    });

    using (sequence.Subscribe(p => Console.Write(p)))
    {
        Console.ReadLine();
    }
}

最后，在你的问题中，日程安排并没有什么“递归的”。你这是什么意思


我终于明白你在看什么了。我在问题中漏掉了

下面是使用递归调度的示例：

IObservable<char> sequence = Observable.Create<char>(o =>
{
    string message = "hello world!";
    return Scheduler.Default.Schedule<string>(message, TimeSpan.FromMilliseconds(250.0), (state, schedule) =>
    {
        if (!String.IsNullOrEmpty(state))
        {
            o.OnNext(state[0]);
            schedule(state.Substring(1), TimeSpan.FromMilliseconds(250.0));
        }
        else
        {
            o.OnCompleted();
        }
    });
});

IObservable sequence=Observable.Create（o=>
{
string message=“你好，世界！”；
返回Scheduler.Default.Schedule（消息，TimeSpan.From毫秒（250.0），（状态，Schedule）=>
{
如果（！String.IsNullOrEmpty（状态））
{
o、 OnNext（state[0]）；
计划（状态子字符串（1），时间跨度从毫秒（250.0））；
}
其他的
{
o、 未完成（）；
}
});
});
这是
.Create
的哪个重载？我无法编译这段代码。投票结果完全是垃圾。Reactive有各种各样的并发规则，这些规则是有充分理由的。有些是违反直觉的。请解释您的投票。“许多好问题都会根据专家经验产生一定程度的意见，但对这个问题的回答往往几乎完全基于意见，而不是事实、参考资料或特定的专业知识。”您能回答我的问题吗？我已经更新了代码。太可怕了。很抱歉。我仍然不相信这是一个比大多数问题更基于观点的问题。这是哪一个超负荷的
.Create
？我无法编译这段代码。投票结果完全是垃圾。Reactive有各种各样的并发规则，这些规则是有充分理由的。有些是违反直觉的。请解释您的投票。“许多好问题都会根据专家经验产生一定程度的意见，但对这个问题的回答往往几乎完全基于意见，而不是事实、参考资料或特定的专业知识。”您能回答我的问题吗？我已经更新了代码。太可怕了。很抱歉。我仍然不相信这是一个比大多数人更基于观点的观点