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

开发 开发工具
ASP.NET MVC 2对于异步模式提供了必要的支持,使此方面的程序设计变得相对简单一些。那么现在我们就来看看一般我们应该如何来实现这样的功能,以及F#是如何美化我们的生活的吧。

在之前的文章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数组作为缓存空间,这样程序在进行数据传输时便不会占用太多内存。

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

  1. public class CompletedEventArgs : EventArgs  
  2. {  
  3.     public CompletedEventArgs(Exception ex)  
  4.     {  
  5.         this.Error = ex;  
  6.     }  
  7.  
  8.     public Exception Error { get; private set; }  

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

  1. public class AsyncTransfer  
  2. {  
  3.     private Stream m_streamIn;  
  4.     private Stream m_streamOut;  
  5.  
  6.     public AsyncTransfer(Stream streamIn, Stream streamOut)  
  7.     {  
  8.         this.m_streamIn = streamIn;  
  9.         this.m_streamOut = streamOut;  
  10.     }  
  11.  
  12.     public void StartAsync()  
  13.     {  
  14.         byte[] buffer = new byte[1024];  
  15.  
  16.         this.m_streamIn.BeginRead(  
  17.             buffer, 0, buffer.Length,  
  18.             this.EndReadInputStreamCallback, buffer);  
  19.     }  
  20.  
  21.     private void EndReadInputStreamCallback(IAsyncResult ar)  
  22.     {  
  23.         var buffer = (byte[])ar.AsyncState;  
  24.         int lengthRead;  
  25.  
  26.         try  
  27.         {  
  28.             lengthRead = this.m_streamIn.EndRead(ar);  
  29.         }  
  30.         catch (Exception ex)  
  31.         {  
  32.             this.OnCompleted(ex);  
  33.             return;  
  34.         }  
  35.  
  36.         if (lengthRead <= 0)  
  37.         {  
  38.             this.OnCompleted(null);  
  39.         }  
  40.         else  
  41.         {  
  42.             try  
  43.             {  
  44.                 this.m_streamOut.BeginWrite(  
  45.                     buffer, 0, lengthRead,  
  46.                     this.EndWriteOutputStreamCallback, buffer);  
  47.             }  
  48.             catch (Exception ex)  
  49.             {  
  50.                 this.OnCompleted(ex);  
  51.             }  
  52.         }  
  53.     }  
  54.  
  55.     private void EndWriteOutputStreamCallback(IAsyncResult ar)  
  56.     {  
  57.         try  
  58.         {  
  59.             this.m_streamOut.EndWrite(ar);  
  60.  
  61.             var buffer = (byte[])ar.AsyncState;  
  62.             this.m_streamIn.BeginRead(  
  63.                 buffer, 0, buffer.Length,  
  64.                 this.EndReadInputStreamCallback, buffer);  
  65.         }  
  66.         catch (Exception ex)  
  67.         {  
  68.             this.OnCompleted(ex);  
  69.         }  
  70.     }  
  71.  
  72.     private void OnCompleted(Exception ex)  
  73.     {  
  74.         var handler = this.Completed;  
  75.         if (handler != null)  
  76.         {  
  77.             handler(this, new CompletedEventArgs(ex));  
  78.         }  
  79.     }  
  80.  
  81.     public event EventHandler<CompletedEventArgs> Completed;  

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

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

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

编写简单的代理

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

  1. public class AsyncWebTransfer  
  2. {  
  3.     private WebRequest m_request;  
  4.     private WebResponse m_response;  
  5.  
  6.     private HttpContextBase m_context;  
  7.     private string m_url;  
  8.  
  9.     public AsyncWebTransfer(HttpContextBase context, string url)  
  10.     {  
  11.         this.m_context = context;  
  12.         this.m_url = url;  
  13.     }  
  14.  
  15.     public void StartAsync()  
  16.     {  
  17.         this.m_request = WebRequest.Create(this.m_url);  
  18.         this.m_request.BeginGetResponse(this.EndGetResponseCallback, null);  
  19.     }  
  20.  
  21.     private void EndGetResponseCallback(IAsyncResult ar)  
  22.     {  
  23.         try  
  24.         {  
  25.             thisthis.m_response = this.m_request.EndGetResponse(ar);  
  26.             thisthis.m_context.Response.ContentType = this.m_response.ContentType;  
  27.  
  28.             var streamIn = this.m_response.GetResponseStream();  
  29.             var streamOut = this.m_context.Response.OutputStream;  
  30.  
  31.             var transfer = new AsyncTransfer(streamIn, streamOut);  
  32.             transfer.Completed += (sender, args) => this.OnCompleted(args.Error);  
  33.             transfer.StartAsync();  
  34.         }  
  35.         catch(Exception ex)  
  36.         {  
  37.             this.OnCompleted(ex);  
  38.         }  
  39.     }  
  40.  
  41.     private void OnCompleted(Exception ex)  
  42.     {  
  43.         if (this.m_response != null)  
  44.         {  
  45.             this.m_response.Close();  
  46.             this.m_response = null;  
  47.         }  
  48.  
  49.         var handler = this.Completed;  
  50.         if (handler != null)  
  51.         {  
  52.             handler(this, new CompletedEventArgs(ex));  
  53.         }  
  54.     }  
  55.  
  56.     public event EventHandler<CompletedEventArgs> Completed;  

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

使用F#完成异步工作

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

  1. let rec transferAsync (streamIn: Stream) (streamOut: Stream) buffer =   
  2.     async {  
  3.         let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)  
  4.         if lengthRead > 0 then  
  5.             do! streamOut.AsyncWrite(buffer, 0, lengthRead)  
  6.             do! transferAsync streamIn streamOut buffer  
  7.     } 

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

  1. let transferImperativelyAsync (streamIn: Stream) (streamOut: Stream) buffer =   
  2.     async {  
  3.         let hasData = ref true  
  4.         while (hasData.Value) do  
  5.             let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)  
  6.             if lengthRead > 0 then  
  7.                 do! streamOut.AsyncWrite(buffer, 0, lengthRead)  
  8.             else  
  9.                 hasData :false 
  10.     } 

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

  1. let webTransferAsync (context: HttpContextBase) (url: string) =  
  2.     async {  
  3.         let request = WebRequest.Create(url)  
  4.         use! response = request.GetResponseAsync()  
  5.         context.Response.ContentType <- response.ContentType  
  6.           
  7.         let streamIn = response.GetResponseStream()  
  8.         let streamOut = context.Response.OutputStream  
  9.         let buffer = Array.zeroCreate 1024  
  10.         do! transferAsync streamIn streamOut buffer  
  11.     } 

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

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

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

  1. [<AbstractClass>]  
  2. type AsyncWorker(asyncWork: Async) =   
  3.       
  4.     let completed = new Event()  
  5.  
  6.     [<CLIEvent>]  
  7.     member e.Completed = completed.Publish  
  8.  
  9.     member e.StartAsync() =   
  10.         Async.StartWithContinuations  
  11.             (asyncWork,  
  12.              (fun _ -> completed.Trigger(new CompletedEventArgs(null))),  
  13.              (fun ex -> completed.Trigger(new CompletedEventArgs(ex))),  
  14.              (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类也可轻易实现了:

  1. type AsyncTransfer(streamIn: Stream, streamOut: Stream) =   
  2.     inherit AsyncWorker(  
  3.         Transfer.transferAsync streamIn streamOut (Array.zeroCreate 1024))  
  4.  
  5. type AsyncWebTransfer(context: HttpContextBase, url: string) =  
  6.     inherit AsyncWorker(Transfer.webTransferAsync context url)最后,只要在ASP.NET MVC中使用即可:  
  7.  
  8. public void LoadFsAsync(string url)  
  9. {  
  10.     AsyncManager.OutstandingOperations.Increment();  
  11.     var transfer = new FSharpAsync.AsyncWebTransfer(HttpContext, url);  
  12.  
  13.     transfer.Completed += (sender, args) => 
  14.         AsyncManager.OutstandingOperations.Decrement();  
  15.  
  16.     transfer.StartAsync();  
  17. }  
  18.  
  19. public ActionResult LoadFsCompleted()  
  20. {  
  21.     return new EmptyResult();  

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

总结

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

【编辑推荐】

  1. F#与ASP.NET:基于事件的异步模式与异步Action
  2. F#中的异步及并行模式:代理的高级使用
  3. F#中的异步及并行模式:反馈进度的事件
  4. 详解F#对象序列化为XML的实现方法
  5. F#中关于代理的基本使用
责任编辑:王晓东 来源: 老赵的博客
相关推荐

2010-04-06 15:20:56

ASP.NET MVC

2010-03-26 19:03:19

F#异步并行模式

2010-01-07 10:04:18

F#函数式编程

2010-01-26 08:25:06

F#语法F#教程

2010-03-26 18:31:59

F#异步并行模式

2010-03-16 09:09:04

F#

2010-01-15 08:33:13

F#F#类型推断F#教程

2009-08-19 09:42:34

F#并行排序算法

2009-11-16 09:05:46

CodeTimer

2010-03-26 19:22:08

F#代理

2009-09-10 14:18:59

Functional F#

2009-08-13 17:25:21

F#入门

2011-06-09 09:52:41

F#

2009-08-13 17:39:48

F#数据类型Discriminat

2012-03-12 12:34:02

JavaF#

2010-03-08 09:17:13

F#异步

2010-12-21 08:53:04

Mono

2010-01-04 09:40:46

F#对象

2009-12-04 09:16:44

Visual Stud

2009-12-14 09:04:10

F#运算符
点赞
收藏

51CTO技术栈公众号