F#与ASP.NET：使用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.   
  
  
  2. {  
    3.   
  
  
  3.     public CompletedEventArgs(Exception ex)  
    4.   
  
  
  4.     {  
    5.   
  
  
  5.         this.Error = ex;  
    6.   
  
  
  6.     }  
    7.   
  
  
  7.  
    8.   
  
  
  8.     public Exception Error { get; private set; }  
    9.   
  
  
  9. } 
    10.

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

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

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

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

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

编写简单的代理

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

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

如果说之前的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.   
  
  
  2.     async {  
    3.   
  
  
  3.         let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)  
    4.   
  
  
  4.         if lengthRead > 0 then  
    5.   
  
  
  5.             do! streamOut.AsyncWrite(buffer, 0, lengthRead)  
    6.   
  
  
  6.             do! transferAsync streamIn streamOut buffer  
    7.   
  
  
  7.     } 
    8.

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

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

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

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

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

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

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

 
 
 
      
  
  
  1. []  
    2.   
  
  
  2. type AsyncWorker(asyncWork: Async) =   
    3.   
  
  
  3.       
    4.   
  
  
  4.     let completed = new Event()  
    5.   
  
  
  5.  
    6.   
  
  
  6.     []  
    7.   
  
  
  7.     member e.Completed = completed.Publish  
    8.   
  
  
  8.  
    9.   
  
  
  9.     member e.StartAsync() =   
    10.   
  
  
  10.         Async.StartWithContinuations  
    11.   
  
  
  11.             (asyncWork,  
    12.   
  
  
  12.              (fun _ -> completed.Trigger(new CompletedEventArgs(null))),  
    13.   
  
  
  13.              (fun ex -> completed.Trigger(new CompletedEventArgs(ex))),  
    14.   
  
  
  14.              (fun ex -> ex |> ignore)) 
    15.

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

事实上，在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#中关于代理的基本使用

分享文章：F#与ASP.NET：使用F#实现基于事件的异步模式
浏览地址：http://www.shufengxianlan.com/qtweb/news19/249269.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

行业网站建设

绵竹网站建设　　 　帝美豪门窗　　 　seo优化排名　　 　成都网站运营维护　　 　VI设计　　 　手机网站建设　　 　晟和广告　　 　微信公众号开发　　 　犀浦封阳台　　 　成都网站设计　　 　攀枝花网站建设　　 　德阳机房托管　　 　解决方案　　 　攀枝花网站建设　　 　网站设计　　 　成都网站建设　　 　主动防护网　　 　app软件开发公司　　 　成都画册设计公司　　 　证企宝