如何在F＃任务计算表达式的每一步上实现非嵌套异常处理？

Posted 2021-05-03

鉴于F＃task computation expression，我可以写： -

task {
    try
        let! accessToken = getAccessTokenAsync a b

        try
            let! resource = getResourceAsync accessToken uri
            // do stuff
        with
            | ex -> printfn "Failed to get API resource.  %s" ex.Message
    with
        | ex -> printfn "Failed to get access token.  %s" ex.Message

    return ()
}

但我想做的是围绕两个getBlahAsync函数调用进行非嵌套异常处理。这可以在C＃中使用多个asyncs的await方法很容易地完成。

如何在F＃计算表达式中这样做？如果我以简单明显的方式尝试它，来自第一个accessToken的try..with不会流入第二个try..with。

（嵌套的麻烦在于// do stuff部分可能会增长一点，推动外部with越来越远离它的try。）

如何在C＃中做到： -

static async Task MainAsync()
{
    String accessToken = null;
    try
    {
        accessToken = await GetAccessTokenAsync("e", "p");
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine("Failed to get access token.  " + ex.Message);
        return;
    }

    String resource = null;
    try
    {
        resource = await GetResourceAsync(accessToken);
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine("Failed to get API resource.  " + ex.Message);
        return;
    }

    // do stuff
}

答案

翻译C＃代码的主要问题是F＃不允许你使用return提前跳出函数体。您可以通过各种方式避免嵌套异常，但您将无法提前返回。这可以作为another computatione expression实现，但这比你实际想要在这里使用的东西更具好奇心。

我的建议是将函数拆分为一个获取所有资源并处理异常的函数和另一个执行这些操作的函数。这并不能消除嵌套，但它会使代码具有可读性。

let doStuff accessToken resource = task {
  // do stuff
}

let getResourcesAndDoStuff a b uri = task {
  try
    let! accessToken = getAccessTokenAsync a b
    try
      let! resource = getResourceAsync accessToken uri
      return! doStuff accessToken resource
    with ex -> 
      printfn "Failed to get API resource.  %s" ex.Message
  with ex ->
    printfn "Failed to get access token.  %s" ex.Message 
}

顺便说一下，你有什么特别的理由使用task而不是普通的内置F＃async工作流程吗？它不一定是个问题，但是async组合得更好并且支持取消，所以它通常是明智的默认选择。

另一答案

在编辑之后，我看到你真正想要的是“早期返回” - 在到达终点之前“中断”执行流程的能力。这在F＃中通常是不可能的（尽管一些计算构建器可能会为此提供专门的工具），因为F＃基本上是基于表达式的，而不是基于语句的。

缺乏早期回报是一件好事，因为它迫使你仔细思考你的计划应该做什么，而不仅仅是哄骗。但这是另一次哲学讨论。

但是，还有其他方法可以达到类似的效果。在这种特定情况下，我会将这两个操作及其异常处理放入单独的函数中，然后将这些函数链接在一起：

task {
    let token = task {
        try
            let! t = getAccessTokenAsync a b
            return Some t
        with
            | ex -> printfn "Failed to get access token.  %s" ex.Message
                    return None
    }

    let resouce t = task {
        try 
            let! r = getResourceAsync accessToken uri
            // do stuff
        with 
            | ex -> printfn "Failed to get API resource.  %s" ex.Message
    }

    let! t = token
    match t with
       | None -> return ()
       | Some token -> do! resource token
}

如果您发现自己经常面临类似的问题，您可能需要投资一些帮助异常处理和Option链接的辅助函数：

// Applies given Task-returning function to the given Option value,
// if the Option value is None, returns None again.
// This is essentially Option.map wrapped in a task.
let (<*>) f x = task {
    match x with
    | None -> return None
    | Some r -> let! r' = f r
                return Some r'
}

// Executes given Option-returning task, returns None if an exception was thrown.
let try'' errMsg f = task {
    try return! f
    with ex -> 
        printfn "%s %s" errMsg ex.Message
        return None
}

// Executes given task, returns its result wrapped in Some,
// or returns None if an exception was thrown.
let try' errMsg f = try'' errMsg <| task { let! r = f
                                           return Some r }


task {
    let! token = getAccessTokenAsync a b |> try' "Failed to get access token."
    let! resource = getResourceAsync uri <*> token |> try'' "Failed to get API resource."
    do! doStuff <*> resource
}

这说明了处理异常的首选F＃方法：避免它们，从不抛出它们，而是返回错误类型（上面的示例使用Option<_>，但也参见Result<_,_>），如果必须与引发异常的库代码进行交互，请将它们在将异常转换为错误类型的包装器中。