代码改变世界

F#与ASP.NET(2):使用F#实现基于事件的异步模式

2010-04-05 20:46 by Jeffrey Zhao, ... 阅读, ... 评论, 收藏, 编辑

上一篇文章中,我们的简单讨论了.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块包围整段逻辑。

编写一个异步程序本来就是那么复杂。

编写简单的代理

嗯,我们继续。现在我们已经有了一个异步传输数据的组件,就用它来做一些有趣的事情吧。例如,我们可以在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
        {
            this.m_response = this.m_request.EndGetResponse(ar);
            this.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#与ASP.NET(2):使用F#实现基于事件的异步模式

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

更多内容,请参考《F#与ASP.NET(2):使用F#实现基于事件的异步模式

总结

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

您可以在这里访问到本文的示例代码,其中我在WebApp项目中实现了简单的入口页面,您访问“/image”便会出现两个文本框,您填入一个URL(例如某幅图片)并提交,它会将URL提交至“/image/load”或“/image/loadfs”中,它们分别使用了C#和F#实现的AsyncWebTransfer类,从效果上说两者完全相同。

相关文章

使用Live Messenger联系我