F#与ASP.NET：使用F#实现基于事件的异步模式-51CTO.COM

在之前的文章F#与ASP.NET：基于事件的异步模式与异步Action中，我们的简单讨论了.NET中两种异步模型以及它们在异常处理上的区别，并且简单观察了ASP.NET MVC 2中异步Action的编写方式。从中我们得知，ASP.NET MVC 2的异步Action并非使用了传统基于Begin/End的异步编程模型，而是另一种基于事件的异步模式。

此外，ASP.NET MVC 2对于这种异步模式提供了必要的支持，使此方面的程序设计变得相对简单一些。但是，简单的原因主要还是在于已经由其他组件提供了良好的，基于事件的异步模式。那么现在我们就来看看一般我们应该如何来实现这样的功能，以及F#是如何美化我们的生活的吧。

异步数据传输

我们为什么要异步，主要目的之一还是提高I/O操作的伸缩性。I/O操作主要是I/O设备的事情，这些设备在好好工作的时候，是不需要系统花心思进行照看的，它们只要能够在完成指定工作后通知系统就可以了。这也是异步I/O高效的原理，因为它将程序从等待I/O完成的苦闷中解脱出来，这对用户或是系统来说都是一件绝好的事情。

那么说到I/O操作，最典型的场景之一便是数据传输了。比如有两个数据流streamIn和streamOut，我们需要异步地从streamIn中读取数据，并异步地写入到streamOut中。在这个过程中，我们使用一个相对较小的byte数组作为缓存空间，这样程序在进行数据传输时便不会占用太多内存。

那么，如果现在需要您编写一个组件完成这样的数据传输工作，并使用标准的基于事件的异步模式释放出来，您会怎么做？基于事件的异步模式，要求在任务完成时使用事件进行提示。同时在出错的时候将异常对象保存在事件的参数中。现在我已经帮您写好了这样的事件参数：

public class CompletedEventArgs : EventArgs  
{  
    public CompletedEventArgs(Exception ex)  
    {  
        this.Error = ex;  
    }  
 
    public Exception Error { get; private set; }  
}

那么接下来的工作就交给您了，以下代码仅供参考：

public class AsyncTransfer  
{  
    private Stream m_streamIn;  
    private Stream m_streamOut;  
 
    public AsyncTransfer(Stream streamIn, Stream streamOut)  
    {  
        this.m_streamIn = streamIn;  
        this.m_streamOut = streamOut;  
    }  
 
    public void StartAsync()  
    {  
        byte[] buffer = new byte[1024];  
 
        this.m_streamIn.BeginRead(  
            buffer, 0, buffer.Length,  
            this.EndReadInputStreamCallback, buffer);  
    }  
 
    private void EndReadInputStreamCallback(IAsyncResult ar)  
    {  
        var buffer = (byte[])ar.AsyncState;  
        int lengthRead;  
 
        try  
        {  
            lengthRead = this.m_streamIn.EndRead(ar);  
        }  
        catch (Exception ex)  
        {  
            this.OnCompleted(ex);  
            return;  
        }  
 
        if (lengthRead <= 0)  
        {  
            this.OnCompleted(null);  
        }  
        else  
        {  
            try  
            {  
                this.m_streamOut.BeginWrite(  
                    buffer, 0, lengthRead,  
                    this.EndWriteOutputStreamCallback, buffer);  
            }  
            catch (Exception ex)  
            {  
                this.OnCompleted(ex);  
            }  
        }  
    }  
 
    private void EndWriteOutputStreamCallback(IAsyncResult ar)  
    {  
        try  
        {  
            this.m_streamOut.EndWrite(ar);  
 
            var buffer = (byte[])ar.AsyncState;  
            this.m_streamIn.BeginRead(  
                buffer, 0, buffer.Length,  
                this.EndReadInputStreamCallback, buffer);  
        }  
        catch (Exception ex)  
        {  
            this.OnCompleted(ex);  
        }  
    }  
 
    private void OnCompleted(Exception ex)  
    {  
        var handler = this.Completed;  
        if (handler != null)  
        {  
            handler(this, new CompletedEventArgs(ex));  
        }  
    }  
 
    public event EventHandler<CompletedEventArgs> Completed;  
}

是不是很复杂的样子？编写异步程序，基本则意味着要将原本同步的调用拆成两段：发起及回调，这样便让上下文状态的保存便的困难起来。幸运的是，C#这门语言提供了方便好用的匿名函数语法，这对于编写一个回调函数来说已经非常容易了。但是，如果需要真正写一个稳定、安全的异步程序，需要做的事情还有很多。

例如，一次异步操作结束之后会执行一个回调函数，那么如果在这个回调函数中抛出了一个异常那该怎么办？如果不正确处理这个异常，轻则造成资源泄露，重则造成进程退出。因此在每个回调函数中，您会发现try...catch块是必不可少的——甚至还需要两段。

更复杂的可能还是在于逻辑控制上。这样一个数据传输操作很显然需要循环——读一段，写一段。但是由于需要编写成二段式的异步调用，因此程序的逻辑会被拆得七零八落，我们没法使用一个while块包围整段逻辑，编写一个异步程序本来就是那么复杂。 #p#

编写简单的代理

现在我们已经有了一个异步传输数据的组件，就用它来做一些有趣的事情吧。例如，我们可以在ASP.NET应用程序中建立一个简单的代理，即给定一个URL，在服务器端发起这样一个请求，并将这个URL的数据传输到客户端来。简单起见，除了进行数据传输之外，我们只需要简单地输出Content Type头信息即可。以下代码仅供参考：

public class AsyncWebTransfer  
{  
    private WebRequest m_request;  
    private WebResponse m_response;  
 
    private HttpContextBase m_context;  
    private string m_url;  
 
    public AsyncWebTransfer(HttpContextBase context, string url)  
    {  
        this.m_context = context;  
        this.m_url = url;  
    }  
 
    public void StartAsync()  
    {  
        this.m_request = WebRequest.Create(this.m_url);  
        this.m_request.BeginGetResponse(this.EndGetResponseCallback, null);  
    }  
 
    private void EndGetResponseCallback(IAsyncResult ar)  
    {  
        try  
        {  
            thisthis.m_response = this.m_request.EndGetResponse(ar);  
            thisthis.m_context.Response.ContentType = this.m_response.ContentType;  
 
            var streamIn = this.m_response.GetResponseStream();  
            var streamOut = this.m_context.Response.OutputStream;  
 
            var transfer = new AsyncTransfer(streamIn, streamOut);  
            transfer.Completed += (sender, args) => this.OnCompleted(args.Error);  
            transfer.StartAsync();  
        }  
        catch(Exception ex)  
        {  
            this.OnCompleted(ex);  
        }  
    }  
 
    private void OnCompleted(Exception ex)  
    {  
        if (this.m_response != null)  
        {  
            this.m_response.Close();  
            this.m_response = null;  
        }  
 
        var handler = this.Completed;  
        if (handler != null)  
        {  
            handler(this, new CompletedEventArgs(ex));  
        }  
    }  
 
    public event EventHandler<CompletedEventArgs> Completed;  
}

如果说之前的AsyncTransfer类是基于“Begin/End异步编程模型”实现的基于事件的异步模式，那么AsyncWebTransfer便是基于“基于事件的异步模式”实现的基于事件的异步模式了。嗯，似乎有点绕口，不过我相信这段代码对您来说还是不难理解的。

使用F#完成异步工作

事实上我已经很久没有写过这样的代码了，咎其原因还是被F#给宠坏了。尝试了C# 2.0之后我便抛弃了Java语言，熟悉了C# 3.0之后我用C# 2.0就快写不了程序了，而使用了F#进行异步编程之后，我就再也没有使用C#写过异步操作了。那么我们就来看看F#是如何进行异步数据传输的吧：

let rec transferAsync (streamIn: Stream) (streamOut: Stream) buffer =   
    async {  
        let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)  
        if lengthRead > 0 then  
            do! streamOut.AsyncWrite(buffer, 0, lengthRead)  
            do! transferAsync streamIn streamOut buffer  
    }

上面的代码利用了尾递归进行不断地数据传输，我们也可以使用传统的while循环来实现这个功能：

let transferImperativelyAsync (streamIn: Stream) (streamOut: Stream) buffer =   
    async {  
        let hasData = ref true  
        while (hasData.Value) do  
            let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)  
            if lengthRead > 0 then  
                do! streamOut.AsyncWrite(buffer, 0, lengthRead)  
            else  
                hasData := false 
    }

有了transferAsync函数，编写一个资源请求的代理也是几分钟的事情：

let webTransferAsync (context: HttpContextBase) (url: string) =  
    async {  
        let request = WebRequest.Create(url)  
        use! response = request.GetResponseAsync()  
        context.Response.ContentType <- response.ContentType  
          
        let streamIn = response.GetResponseStream()  
        let streamOut = context.Response.OutputStream  
        let buffer = Array.zeroCreate 1024  
        do! transferAsync streamIn streamOut buffer  
    }

没错，就是这么简单，这就是F#中编写异步任务方式。在执行这两个函数时（当然确切地说，是执行这两个函数所生成的异步工作流），便会在出现“感叹号”的操作之处自动分成二段式的异步调用，但是在程序的写法上和同步代码可谓毫无二致。 #p#

使用F#实现基于事件的异步模式

当然，光有上面的代码还不够，因为这样的代码无法交给C#代码来使用，我们还需要将它们封装成基于事件的异步模式。不过这也非常简单，使用一个通用的抽象基类即可：

[<AbstractClass>]  
type AsyncWorker(asyncWork: Async) =   
      
    let completed = new Event()  
 
    [<CLIEvent>]  
    member e.Completed = completed.Publish  
 
    member e.StartAsync() =   
        Async.StartWithContinuations  
            (asyncWork,  
             (fun _ -> completed.Trigger(new CompletedEventArgs(null))),  
             (fun ex -> completed.Trigger(new CompletedEventArgs(ex))),  
             (fun ex -> ex |> ignore))

在使用F#进行面向对象开发时，由于不需要C#的架子代码，它实现相同的结构一般都会显得紧凑不少（不过在我看来，C#在进行一般的命令式编程时还是比F#来的方便一些）。在StartAsync方法中，我们使用Async.StartWithContinuations发起一个异步工作流，而这个异步工作流便是从构造函数中传入的具体任务。StartWithContinuations方法的后三个参数分别是成功时的回调，失败后的回调，以及任务取消后的回调。您可能会说，难道F#中不需要异常处理，不需要资源释放吗？当然需要。只不过：

1) 异常处理已经由StartWithContinuations统一完成了，我们只要按照“同步式”代码的写法编写逻辑，也就是说，从语义上说您可以看作存在一个巨大的try...catch围绕着整段代码。

2) 而对于资源释放来说，您可以发现在webTransferAsync方法中有一个use!指令，这便是告诉F#的异步框架，在整个异步工作流结束之后需要调用这个资源的Dispose方法——没错，您可以把它看作是一种能在异步环境下工作的C# using关键字。有了AsyncWorker类之后，AsyncTransfer和WebAsyncTransfer类也可轻易实现了：

type AsyncTransfer(streamIn: Stream, streamOut: Stream) =   
    inherit AsyncWorker(  
        Transfer.transferAsync streamIn streamOut (Array.zeroCreate 1024))  
 
type AsyncWebTransfer(context: HttpContextBase, url: string) =  
    inherit AsyncWorker(Transfer.webTransferAsync context url)最后，只要在ASP.NET MVC中使用即可：  
 
public void LoadFsAsync(string url)  
{  
    AsyncManager.OutstandingOperations.Increment();  
    var transfer = new FSharpAsync.AsyncWebTransfer(HttpContext, url);  
 
    transfer.Completed += (sender, args) => 
        AsyncManager.OutstandingOperations.Decrement();  
 
    transfer.StartAsync();  
}  
 
public ActionResult LoadFsCompleted()  
{  
    return new EmptyResult();  
}

事实上，在ImageController中我还提供了一个LoadAsync及对应的LoadCompleted方法，它们使用的是利用C#实现的AsyncWebTransfer类。猜猜看这样的代码长成什么样？其实只是将上面的AsyncWebTransfer的命名空间改成CSharpAsync而已——F#与其它.NET代码是真正做到无缝集成的。

总结

这便是F#的伟大之处。时常有朋友会问我为什么对F#有那么大的兴趣，我想，如果借助F#可以用十分之一的时间，十分之一的代码行数，写出执行效果相同，但可维护性高出好几倍的程序来。

【编辑推荐】