F# 异步处置

Question

我写了这个小的网络侦听器模拟：

Agent.Start(fun (_ : MailboxProcessor<unit>) ->
        let listener = new HttpListener()
        listener.Prefixes.Add(addr)
        listener.Start()

        let rec respondOut() = async {
                let! context = Async.FromBeginEnd(listener.BeginGetContext, listener.EndGetContext)
                use s = context.Response.OutputStream
                let wr = new StreamWriter(s)
                use disp = { new IDisposable with
                                member x.Dispose() =
                                    printfn "Disposing..."
                                    wr.Dispose() }
                wr.Write("Test")
                return! respondOut()
            }

        respondOut()
    )

我不明白为什么在每个循环的 disp 上不调用 Dispose？

作为一个附带问题，我这样做是因为我想测试在网络服务中响应文本的正确行为是什么。我不确定我是否应该做：

use s = Context.Response.OutputStream
use sw = new StreamWriter(s)
    sw.Write("test")

或者

Context.Response.Write("Test")
Context.Response.End()

或者诸如此类的事情。

谢谢！

Answer 1

如有疑问，请使用反射器:)。 use 关键字创建“using”的范围，直到块结束。在异步工作流程中使用时，如果对 async 关键字进行脱糖处理，您将得到类似以下内容：

Async.Bind(Async.FromBeginEnd(listener.BeginGetContext, listener.EndGetContext)
           (fun context ->
                use s = context.Response.OutputStream
                let wr = new StreamWriter(s)
                use disp = { new IDisposable with
                                member x.Dispose() =
                                    printfn "Disposing..."
                                    wr.Dispose() }
                wr.Write("Test")
                Async.ReturnFrom ( respondOut() )
                )

现在，调用 Async.ReturnFrom 最后将继续递归调用该函数，并且如果您将 use 替换为“ C# using() { } ”，其中} 括号位于 Async.ReturnFrom 之后，则永远不会调用 dispose

将 use 部分包装在 do 块中应该可以解决问题：

let rec respondOut() = async {
                let! context = Async.FromBeginEnd(listener.BeginGetContext, listener.EndGetContext)
                do 
                    use s = context.Response.OutputStream
                    let wr = new StreamWriter(s)
                    use disp = { new IDisposable with
                                    member x.Dispose() =
                                        printfn "Disposing..."
                                        wr.Dispose() }
                    wr.Write("Test")
                return! respondOut()
            }

Answer 2

use 扩展到块的末尾，因此我希望 Dispose 在递归计算返回之后被调用（在这个例子中，从来没有）情况，因为它无条件循环）。如果您想提前处理资源，则需要以某种方式界定 use 绑定的范围。也许这样的事情会起作用（我还没有尝试过）：

let rec respondOut() = async {
    let! context = Async.FromBeginEnd(listener.BeginGetContext, listener.EndGetContext)
    do! async {
        use s = context.Response.OutputStream
        let wr = new StreamWriter(s)
        use disp = { new IDisposable with
                     member x.Dispose() =
                         printfn "Disposing..."
                         wr.Dispose() }
        wr.Write("Test")
    }
    return! respondOut()
}

Answer 3

我的猜测是 disp 在编译的代码中被优化掉了，因为它没有被使用。尝试在下一行添加 printfn "%A" disp 。