F#中的异步控制器操作

Question

使用C# - ASP.NET MVC 4,我可以定义一个异步控制器动作,如:

public async Task<ActionResult> IndexWorks()
{
    var data = await DownloadAsync("http://stackoverflow.com");
    return Content(data);
}

有没有办法做类似的事情,使用F#？

我知道我可以使用这种AsyncManager方法.我也知道@Tomas Petricek做得很整洁AsyncActionBuilder,但与C#方法相比,感觉就像很多样板.

Answer 1

async/await使用Tasks,因此您需要在Task对象和F#Async对象之间来回转换.要从Task转换为Async,请使用Async.AwaitTask.做相反的用法Async.StartAsTask.你的例子变成:

member x.IndexWorks() =
    async {
        let! data = Async.AwaitTask (DownloadAsync "http://stackoverflow.com")
        return x.Content(data)
    } |> Async.StartAsTask

或者,async您可以使用适用于开箱即用的任务的计算表达式,而不是使用计算表达式.FSharpx中有一个:

let task = FSharpx.Task.TaskBuilder()

(...)

member x.IndexWorks() = task {
    let! data = DownloadAsync "http://stackoverflow.com"
    return x.Content(data)
}

Answer 2

实际上，看起来像一位程序员同事德米特里·莫罗佐夫（Dmitry Morozov）已经使这样的事情成为可能。他制定了一个习惯，使得从一个地方AsyncWorkflowController回来成为可能。代码可以在http://fssnip.net/5q找到。Async<ActionResult>ActionResultAsyncWorkFlowController

然而，他的实现使得调试非常困难，因为在自定义控制器中重新抛出时不会保留堆栈跟踪。因此我做了一些改变来实现这一点：

 member actionDesc.EndExecute(asyncResult) =
    match endAsync'.Value(asyncResult) with
        | Choice1Of2 value -> box value
        | Choice2Of2 why -> 
            // Preserve the stack trace, when rethrow 
            ExceptionDispatchInfo.Capture(why).Throw() 
            obj() (* Satisfy return value *) } } }

我还更改了以下行：new ReflectedControllerDescriptor(controllerType)，

to new ReflectedAsyncControllerDescriptor(controllerType)- 然而，此更改纯粹是可选的，因为它不会产生任何影响。我只是发现使用这个更合乎逻辑Async。

完整的代码将是：

open System
open System.Web.Mvc
open System.Web.Mvc.Async
open System.Runtime.ExceptionServices

open Unchecked

type AsyncWorkflowController() = 
    inherit AsyncController()

    override __.CreateActionInvoker() = 
        upcast { new AsyncControllerActionInvoker() with

                member __.GetControllerDescriptor(controllerContext) =
                    let controllerType = controllerContext.Controller.GetType()

                    upcast { new ReflectedAsyncControllerDescriptor(controllerType) with 
                            member ctrlDesc.FindAction(controllerContext, actionName) =
                                let forwarder = base.FindAction(controllerContext, actionName) :?> ReflectedActionDescriptor

                                if(forwarder = null || forwarder.MethodInfo.ReturnType <> typeof<Async<ActionResult>>) then
                                    upcast forwarder
                                else 
                                let endAsync' = ref (defaultof<IAsyncResult -> Choice<ActionResult, exn>>)

                                upcast { new AsyncActionDescriptor() with

                                        member actionDesc.ActionName = forwarder.ActionName
                                        member actionDesc.ControllerDescriptor = upcast ctrlDesc
                                        member actionDesc.GetParameters() = forwarder.GetParameters()

                                        member actionDesc.BeginExecute(controllerContext, parameters, callback, state) =
                                            let asyncWorkflow = 
                                                forwarder.Execute(controllerContext, parameters) :?> Async<ActionResult>
                                                |> Async.Catch
                                            let beginAsync, endAsync, _ = Async.AsBeginEnd(fun () -> asyncWorkflow)
                                            endAsync' := endAsync
                                            beginAsync((), callback, state)

                                        member actionDesc.EndExecute(asyncResult) =
                                            match endAsync'.Value(asyncResult) with
                                                | Choice1Of2 value -> box value
                                                | Choice2Of2 why -> 
                                                    // Preserve the stack trace, when rethrow 
                                                    ExceptionDispatchInfo.Capture(why).Throw() 
                                                    obj() (* Satisfy return value *) } } }

用法：

type TestController() =
    inherit AsyncWorkflowController()

    member x.IndexWorks() = async {
        let startThread = Thread.CurrentThread.ManagedThreadId
        let! data = asyncDownload "http://stackoverflow.com"
        let endThread = Thread.CurrentThread.ManagaedThreadId
        return ContentResult(Content = "Start = %i | End = %i" startThread endThread) :> ActionResult }

要确认它实际上异步执行所有操作，并且没有阻止 ASP.NET 池中的任何线程，请使用：

member x.IndexWorks() = async {
    let startThread = Thread.CurrentThread.ManagedThreadId
    let! data = asyncDownload "http://stackoverflow.com"
    let endThread = Thread.CurrentThread.ManagaedThreadId
    return ContentResult(Content = "Start = %i | End = %i" startThread endThread) :> ActionResult }

起始线程和结束线程将不同，因此起始线程被放回到池中，并且当异步操作完成时返回一个新线程。