为什么 Async.StartChild 返回 `Async<Async<'T>>`？

Question

我对 F# 非常陌生，我一直在阅读 F# 的乐趣和利润。在为什么使用 F#？ 系列中，有一个 post 描述了异步代码。我遇到了Async.StartChild 函数，我不明白为什么返回值是这样的。

例子：

let sleepWorkflow  = async {
    printfn "Starting sleep workflow at %O" DateTime.Now.TimeOfDay
    do! Async.Sleep 2000
    printfn "Finished sleep workflow at %O" DateTime.Now.TimeOfDay
}

let nestedWorkflow  = async {

    printfn "Starting parent"
    let! childWorkflow = Async.StartChild sleepWorkflow

    // give the child a chance and then keep working
    do! Async.Sleep 100
    printfn "Doing something useful while waiting "

    // block on the child
    let! result = childWorkflow

    // done
    printfn "Finished parent"
}

我的问题是为什么Async.StartChild 不应该只返回Async<'T> 而不是Async<Async<'T>>？你必须使用let! 两次。 documentation 甚至声明：

此方法通常应用作 let 的直接右侧！ F# 异步工作流中的绑定 [...] 以这种方式使用时，每次使用 StartChild 都会启动 childComputation 的实例并返回一个表示计算的完成器对象以等待操作完成。执行时，完成者等待 childComputation 的完成。

在一些测试中，添加了一些睡眠调用，似乎没有初始的let!，子计算永远不会开始。

为什么会有这种返回类型/行为？我习惯了 C# 调用 async 方法总是会立即“启动”任务，即使您不使用 await 它也是如此。事实上，在 C# 中，如果 async 方法不调用任何异步代码，它就会同步运行。

编辑澄清：

这样做有什么好处：

let! waiter = Async.StartChild otherComp // Start computation
// ...
let! result = waiter // Block

与Async.StartChild 返回Async<'T> 相比：

let waiter = Async.StartChild otherComp // Start computation
// ...
let !result = waiter // Block

Answer 1

这个想法是这样的：你用let wait = Async.StartChild otherComp 开始另一个异步计算（在后台），然后你得到服务员。

这意味着let! result = waiter 将阻塞并随时等待后台计算的结果。

如果Async.StartChild 会返回一个Async<'t>，你会wait 和let! x = otherComp 就在那里，它就像一个正常 让！结果 = otherComp`

---

是的，F# Async-Workflows 只有在您执行Async.Start... 或Async.RunSynchronously 之类的操作后才会启动（它不像Task 通常在您创建后立即运行）

这就是为什么在 C# 中您可以在某一时刻创建一个任务 (var task = CreateMyTask())（即 Async.StartChild 部分），然后使用 var result = await task 在那里等待结果（即 let! result = waiter 部分)。

---

为什么Async.StartChild 返回Async<Async<'T>> 而不是Async<'T>

这是因为以这种方式启动的工作流应该表现得像一个子-任务/进程。当您取消包含的工作流程时，child 也应该取消。

因此，在技术层面上，子工作流需要访问取消令牌，而无需您明确传递它，这是您使用 Bind（又名@ 987654338@这里）。

所以它必须是这种类型才能使取消令牌的传递起作用。

Answer 2

我一直在思考这个问题，但无法给出一个可靠的解释。事实上，作为概念证明，我能够编写具有您想要的行为的 StartChild 的粗略版本：

let myStartChild computation =

    let mutable resultOpt = None
    let handle = new ManualResetEvent(false)

    async {
        let! result = computation   // run the computation
        resultOpt <- Some result    // store the result
        handle.Set() |> ignore      // signal that the computation has completed
    } |> Async.Start

    async {
        handle.WaitOne() |> ignore   // wait for the signal
        handle.Dispose()             // cleanup
        return resultOpt.Value       // return the result
    }

我写了一个基本的烟雾测试，它似乎工作正常，所以要么我忽略了一些重要的事情（可能与取消令牌有关？），要么你的问题的答案是它不一定是那样。

无论如何，我都不是Async 专家，所以我希望有人比我更有知识。

更新：根据 Carsten 的更新答案，我认为我们有一个完整的解释：您可以：

• 拥有您想要的签名，但不支持取消，或者
• 如果您需要取消，请使用标准的Async<Async<'T>> 签名。

第二个版本更灵活，这就是它在标准库中的原因。