[C#学习笔记之异步编程模式2]BeginInvoke和EndInvoke方法 (转载)

为什么要进行异步回调？众所周知，普通方法运行，是单线程的，如果中途有大型操作（如：读取大文件，大批量操作数据库，网络传输等），都会导致方法阻塞，表现在界面上就是，程序卡或者死掉，界面元素不动了，不响应了。异步方法很好的解决了这些问题，异步执行某个方法，程序立即开辟一个新线程去运行你的方法，主线程包括界面就不会死掉了。异步调用并不是要减少线程的开销, 它的主要目的是让调用方法的主线程不需要同步等待在这个函数调用上, 从而可以让主线程继续执行它下面的代码.

      BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。当使用BeginInvoke异步调用方法时，如果方法未执行完，EndInvoke方法就会一直阻塞，直到被调用的方法执行完毕。


 

异步调用通用模板

 
//……
//普通的代码：处于同步执行模式
IAsyncResultret=委托变量.BeginInvoke(……); //启动异步调用
//可以在这一部分干其他一些事，程序处于异步执行模式
用于保存方法结果的变量＝委托变量.EndInvoke(ret); //结束异步调用
//普通的代码：处于同步执行模式
//……
 
对照上一篇文章中的计算指定文件夹的容量的例子（例2）
[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.IO;  
  5.   
  6.   
  7. namespace AsyncCalculateFolderSize1  
  8. {  
  9.     class Program  
  10.     {  
  11.         //计算指定文件夹的总容量   
  12.         private static long CalculateFolderSize(string FolderName)  
  13.         {  
  14.             if (Directory.Exists(FolderName) == false)  
  15.             {  
  16.                 throw new DirectoryNotFoundException("文件夹不存在");  
  17.             }  
  18.   
  19.             DirectoryInfo RootDir = new DirectoryInfo(FolderName);  
  20.               
  21.             //获取所有的子文件夹   
  22.             DirectoryInfo[] ChildDirs = RootDir.GetDirectories();  
  23.             //获取当前文件夹中的所有文件   
  24.             FileInfo[] files = RootDir.GetFiles();  
  25.             long totalSize = 0;  
  26.             //累加每个文件的大小   
  27.             foreach (FileInfo file in files)  
  28.             {  
  29.                 totalSize += file.Length;  
  30.             }  
  31.             //对每个文件夹执行同样的计算过程：累加其下每个文件的大小  
  32.             //这是通过递归调用实现的   
  33.             foreach (DirectoryInfo dir in ChildDirs)  
  34.             {  
  35.                 totalSize += CalculateFolderSize(dir.FullName);  
  36.             }  
  37.             //返回文件夹的总容量   
  38.             return totalSize;  
  39.         }  
  40.   
  41.         //定义一个委托   
  42.         public delegate long CalculateFolderSizeDelegate(string FolderName);  
  43.   
  44.         static void Main(string[] args)  
  45.         {  
  46.   
  47.             //定义一个委托变量引用静态方法CalculateFolderSize  
  48.             CalculateFolderSizeDelegate d = CalculateFolderSize;  
  49.              
  50.             Console.WriteLine("请输入文件夹名称(例如:C:\Windows):");  
  51.   
  52.             string FolderName = Console.ReadLine();  
  53.   
  54.             //通过委托异步调用静态方法CalculateFolderSize  
  55.             IAsyncResult ret=d.BeginInvoke(FolderName,null,null);  
  56.   
  57.             Console.WriteLine("正在计算中，请耐心等待……");  
  58.             //阻塞，等到调用完成，取出结果   
  59.             long size = d.EndInvoke(ret);  
  60.               
  61.             Console.WriteLine(" 计算完成。文件夹{0}的容量为:{1}字节 ", FolderName, size);  
  62.         }  
  63.     }  
  64. }  

异步调用的奥秘

异步调用是通过委托来进行的，我们看看是如何定义委托的：
[csharp] view plaincopyprint?
  1. public delegate long CalculateFolderSizeDelegate(string FolderName);  
通过Reflactor反编译结果如下：                                    
[csharp] view plaincopyprint?
  1. public sealed class CalculateFolderSizeDelegate: MulticastDelegate  
  2. {  
  3. public CalculateFolderSizeDelegate(Object target , intmethodPtr)  
  4. { …… }  
  5. public virtual long invoke(string FolderName)  
  6. { …… }  
  7. public virtual IAsyncResult BeginInvoke( string FolderName,  
  8. AsyncCallbackcallback , object asyncState)  
  9. { …… }  
  10. public virtual long EndInvoke( IAsyncResultresult )  
  11. { …… }  
  12. }  
由此我们发现，当我们定义一个委托的时候，实际上是定义了一个委托类型，这个类型有invoke、BeginInvoke()、EndInvoke()这样几个成员方法，而这几个成员方法可以实现一步调用机制。我们看看这几个方法格式怎么定义的：
 

(1)BeginInvoke方法用于启动异步调用

 

BeginInvoke()的函数声明：

public IAsyncResult BeginInvoke(

         <输入和输出变量>,回调函数callback , 附加信息AsyncState)

函数返回值类型：

public interface IAsyncResult

{

        object AsyncState{ get;}  //如果有回调函数的话该参数用于保存要传递给回调函数的参数值

        WaitHandle AsyncWaitHandle{ get;}

        bool CompletedSynchronously{ get;}

        bool IsCompleted{ get;} //保存方法是否执行结束，我们可以通过该属性的值来判断异步方法是否执行结束

}

1.BeginInvoke返回IasyncResult，可用于监视调用进度。

2.结果对象IAsyncResult是从开始操作返回的，并且可用于获取有关异步开始操作是否已完成的状态。

3.结果对象被传递到结束操作，该操作返回调用的最终返回值。

4.在开始操作中可以提供可选的回调。如果提供回调，在调用结束后，将调用该回调；并且回调中的代码可以调用结束操作。

5.如果需要将一些额外的信息传送给回调函数，就将其放入BeginInvoke()方法的第3个参数asyncState中。注意到这个参数的类型为Object，所以可以放置任意类型的数据。如果有多个信息需要传送给回调函数，可以将所有要传送的信息封状到一个Struct变量，或者干脆再定义一个类，将信息封装到这个类所创建的对象中，再传送给BeginInvoke()方法。

(2)EndInvoke方法用于检索异步调用结果。

方法声明：

      public <方法返回值类型>EndInvoke(<声明为ref或out的参数>, IAsyncResult result )

1.result参数由BeginInvoke()方法传回。.NET借此以了解方法调用是否完成。

2.当EndInvoke方法发现异步调用完成时，它取出此异步调用方法的返回值作为其返回值，如果异步调用方法有声明为ref和out的参数，它也负责填充它。

3.在调用BeginInvoke后可随时调用EndInvoke方法,注意：始终在异步调用完成后调用EndInvoke.
4.如果异步调用未完成，EndInvoke将一直阻塞到异步调用完成。
5.EndInvoke的参数包括需要异步执行的方法的out和ref参数以及由BeginInvoke返回的IAsyncResult。

应用实例：

 
1.使用轮询等待异步调用完成：使用IAsyncResult的IsCompleted属性来判断异步调用是否完成
 
 虽然上面的方法可以很好地实现异步调用，但是当调用EndInvoke方法获得调用结果时，整个程序就象死了一样，依然要等待异步方法执行结束，这样做用户的感觉并不会太  好，因此，我们可以使用 asyncResult来判断异步调用是否完成，并显示一些提示信息。这样做可以增加用户体验。代码如下：
[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.IO;  
  5.   
  6. namespace AsyncCalculateFolderSize2  
  7. {  
  8.     class Program  
  9.     {  
  10.         //计算指定文件夹的总容量   
  11.         private static long CalculateFolderSize(string FolderName)  
  12.         {  
  13.             if (Directory.Exists(FolderName) == false)  
  14.             {  
  15.                 throw new DirectoryNotFoundException("文件夹不存在");  
  16.             }  
  17.             DirectoryInfo RootDir = new DirectoryInfo(FolderName);  
  18.             //获取所有的子文件夹   
  19.             DirectoryInfo[] ChildDirs = RootDir.GetDirectories();  
  20.             //获取当前文件夹中的所有文件   
  21.             FileInfo[] files = RootDir.GetFiles();  
  22.             long totalSize = 0;  
  23.             //累加每个文件的大小   
  24.             foreach (FileInfo file in files)  
  25.             {  
  26.                 totalSize += file.Length;  
  27.             }  
  28.             //对每个文件夹执行同样的计算过程：累加其下每个文件的大小   
  29.             //这是通过递归调用实现的   
  30.             foreach (DirectoryInfo dir in ChildDirs)  
  31.             {  
  32.                 totalSize += CalculateFolderSize(dir.FullName);  
  33.             }  
  34.             //返回文件夹的总容量   
  35.             return totalSize;          
  36.         }  
  37.   
  38.         //定义一个委托   
  39.         public delegate long CalculateFolderSizeDelegate(string FolderName);  
  40.   
  41.         static void Main(string[] args)  
  42.         {  
  43.             //定义一个委托变量引用静态方法CalculateFolderSize  
  44.             CalculateFolderSizeDelegate d = CalculateFolderSize;  
  45.             Console.WriteLine("请输入文件夹名称(例如:C:\Windows):");  
  46.             string FolderName = Console.ReadLine();  
  47.   
  48.             //通过委托异步调用静态方法CalculateFolderSize  
  49.             IAsyncResult ret = d.BeginInvoke(FolderName, null, null);  
  50.   
  51.             Console.Write ("正在计算中，请耐心等待");  
  52.   
  53.             //每隔2秒检查一次,输出一个“."  
  54.             while (ret.IsCompleted == false)  
  55.             {  
  56.                 Console.Write(".");  
  57.                 System.Threading.Thread.Sleep(200);  
  58.             }  
  59.   
  60.             //阻塞，等到调用完成，取出结果   
  61.             long size = d.EndInvoke(ret);  
  62.             Console.WriteLine(" 计算完成! 文件夹{0}的容量为:{1}字节", FolderName, size);  
  63.         }  
  64.     }  
  65. }  
这样，当程序在执行CalculateFolderSize这个异步方法的时候主线程并不是“假死”，而是每隔0.2毫秒输出一个“."，这就是异步调用的妙处！
这里需要用到BeginInvoke的返回值IAsyncResult的IsCompleted这个属性来判断异步线程是否执行结束。

2. 使用轮询等待异步调用完成：使用IAsyncResult的AsyncWaitHandle.WaitOne
 
[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.IO;  
  6.   
  7. namespace AsyncCalculateFolderSize3  
  8. {  
  9.     class Program  
  10.     {  
  11.         //计算指定文件夹的总容量   
  12.         private static long CalculateFolderSize(string FolderName)  
  13.         {  
  14.             if (Directory.Exists(FolderName) == false)  
  15.             {  
  16.                 throw new DirectoryNotFoundException("文件夹不存在");  
  17.             }  
  18.   
  19.             DirectoryInfo RootDir = new DirectoryInfo(FolderName);  
  20.             //获取所有的子文件夹   
  21.             DirectoryInfo[] ChildDirs = RootDir.GetDirectories();  
  22.             //获取当前文件夹中的所有文件   
  23.             FileInfo[] files = RootDir.GetFiles();  
  24.             long totalSize = 0;  
  25.             //累加每个文件的大小   
  26.             foreach (FileInfo file in files)  
  27.             {  
  28.                 totalSize += file.Length;  
  29.             }  
  30.             //对每个文件夹执行同样的计算过程：累加其下每个文件的大小   
  31.             //这是通过递归调用实现的   
  32.             foreach (DirectoryInfo dir in ChildDirs)  
  33.             {  
  34.                 totalSize += CalculateFolderSize(dir.FullName);  
  35.             }  
  36.             //返回文件夹的总容量   
  37.             return totalSize;  
  38.   
  39.         }  
  40.   
  41.         //定义一个委托   
  42.         public delegate long CalculateFolderSizeDelegate(string FolderName);  
  43.   
  44.         static void Main(string[] args)  
  45.         {  
  46.             //定义一个委托变量引用静态方法CalculateFolderSize  
  47.             CalculateFolderSizeDelegate d = CalculateFolderSize;  
  48.   
  49.             Console.WriteLine("请输入文件夹名称(例如:C:\Windows):");  
  50.   
  51.             string FolderName = Console.ReadLine();  
  52.   
  53.             //通过委托异步调用静态方法CalculateFolderSize  
  54.             IAsyncResult ret = d.BeginInvoke(FolderName, null, null);  
  55.   
  56.             Console.Write("正在计算中，请耐心等待");  
  57.   
  58.             while(!ret.AsyncWaitHandle.WaitOne(2000))  
  59.             {  
  60.                 //等待2秒钟，输出一个“.”   
  61.                 Console.Write(".");  
  62.             }  
  63.   
  64.             //阻塞，等到调用完成，取出结果   
  65.             long size = d.EndInvoke(ret);  
  66.   
  67.             Console.WriteLine(" 计算完成。文件夹{0}的容量为:{1}字节 ", FolderName, size);  
  68.         }  
  69.     }  
  70. }  
 WaitOne的第一个参数表示要等待的毫秒数，在指定时间之内，WaitOne方法将一直等待，直到异步调用完成，并发出通知，WaitOne方法才返回true。当等待指定时间之后，异步调用仍未完成，WaitOne方法返回false，如果指定时间为0，表示不等待，如果为-1，表示永远等待，直到异步调用完成。

3.使用异步回调函数
[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.IO;  
  5.   
  6. namespace AsyncCalculateFolderSize4  
  7. {  
  8.     class Program  
  9.     {  
  10.         //计算指定文件夹的总容量   
  11.         private static long CalculateFolderSize(string FolderName)  
  12.         {  
  13.             if (Directory.Exists(FolderName) == false)  
  14.             {  
  15.                 throw new DirectoryNotFoundException("文件夹不存在");  
  16.             }  
  17.   
  18.             DirectoryInfo RootDir = new DirectoryInfo(FolderName);  
  19.             //获取所有的子文件夹   
  20.             DirectoryInfo[] ChildDirs = RootDir.GetDirectories();  
  21.             //获取当前文件夹中的所有文件   
  22.             FileInfo[] files = RootDir.GetFiles();  
  23.             long totalSize = 0;  
  24.             //累加每个文件的大小   
  25.             foreach (FileInfo file in files)  
  26.             {  
  27.                 totalSize += file.Length;  
  28.             }  
  29.             //对每个文件夹执行同样的计算过程：累加其下每个文件的大小  
  30.             //这是通过递归调用实现的   
  31.             foreach (DirectoryInfo dir in ChildDirs)  
  32.             {  
  33.                 totalSize += CalculateFolderSize(dir.FullName);  
  34.             }  
  35.             //返回文件夹的总容量   
  36.             return totalSize;  
  37.         }  
  38.          
  39.         public delegate long CalculateFolderSizeDelegate(string FolderName);  
  40.         private static CalculateFolderSizeDelegate task = CalculateFolderSize;  
  41.   
  42.         //用于回调的函数   
  43.         public static void ShowFolderSize(IAsyncResult result)  
  44.         {  
  45.             long size = task.EndInvoke(result);  
  46.             Console.WriteLine(" 文件夹{0}的容量为:{1}字节 ", (String)result.AsyncState, size);  
  47.         }  
  48.   
  49.         static void Main(string[] args)  
  50.         {  
  51.             string FolderName;  
  52.             while (true)  
  53.             {  
  54.                 Console.WriteLine("请输入文件夹名称(例如:C:\Windows),输入quit结束程序");  
  55.                 FolderName = Console.ReadLine();  
  56.                 if (FolderName == "quit")  
  57.                     break;  
  58.                 task.BeginInvoke(FolderName, ShowFolderSize, FolderName);//第一个参数是异步函数的参数,第二个参数是回调函数,第三个参数是回调函数的参数，回调函数会在异步函数执行结束之后被调用。  
  59.             }  
  60.         }  
  61.     }  
  62. }  
这个例子中通过循环的输入文件夹名称计算文件夹容量，计算的操作放在异步调用函数中，因此我们在输入下一个文件夹名称时不必等待上一个计算结束，异步函数执行完成之后会自动调用回调函数ShowFolderSize进行结果处理。
(今天就学到这里，下午去嘉禾看期待已久的3D《复仇者联盟》，吼吼......)
2012/5/20 23:05补充
 
对于上面最后一个异步回调的例子有一个缺陷，就是当异步调用的函数与主线程都需要访问同一资源时，要注意解决资源共享的问题。如下图：
修改程序如下：
[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.IO;  
  5.   
  6. namespace AsyncCalculateFolderSize6  
  7. {  
  8.     class Program  
  9.     {  
  10.           //计算指定文件夹的总容量   
  11.         private static long CalculateFolderSize(string FolderName)  
  12.         {  
  13.             if (Directory.Exists(FolderName) == false)  
  14.             {  
  15.                 throw new DirectoryNotFoundException("文件夹不存在");  
  16.             }  
  17.   
  18.             DirectoryInfo RootDir = new DirectoryInfo(FolderName);  
  19.             //获取所有的子文件夹   
  20.             DirectoryInfo[] ChildDirs = RootDir.GetDirectories();  
  21.             //获取当前文件夹中的所有文件   
  22.             FileInfo[] files = RootDir.GetFiles();  
  23.             long totalSize = 0;  
  24.             //累加每个文件的大小   
  25.             foreach (FileInfo file in files)  
  26.             {  
  27.                 totalSize += file.Length;  
  28.             }  
  29.             //对每个文件夹执行同样的计算过程：累加其下每个文件的大小  
  30.             //这是通过递归调用实现的   
  31.             foreach (DirectoryInfo dir in ChildDirs)  
  32.             {  
  33.                 totalSize += CalculateFolderSize(dir.FullName);  
  34.             }  
  35.             //返回文件夹的总容量   
  36.             return totalSize;  
  37.         }  
  38.   
  39.         //定义一个委托   
  40.         public delegate long CalculateFolderSizeDelegate(string FolderName);  
  41.         private static CalculateFolderSizeDelegate d = new CalculateFolderSizeDelegate(CalculateFolderSize);  
  42.   
  43.         //用于回调的函数   
  44.         public static void ShowFolderSize(IAsyncResult result)  
  45.         {  
  46.             try  
  47.             {  
  48.                 long size = d.EndInvoke(result);  
  49.                 while (Console.CursorLeft != 0)//只有用户不输入，且光标位于第一列时，才输出信息。  
  50.                 {  
  51.                     //等待2秒   
  52.                     System.Threading.Thread.Sleep(2000);  
  53.                 }  
  54.                 Console.WriteLine(" 文件夹{0}的容量为:{1}字节 ", (String)result.AsyncState, size);  
  55.             }  
  56.             catch (DirectoryNotFoundException e)  
  57.             {  
  58.                 Console.WriteLine("您输入的文件夹不存在");  
  59.             }  
  60.         }  
  61.   
  62.         static void Main(string[] args)  
  63.         {  
  64.             string FolderName;  
  65.             while (true)  
  66.             {  
  67.                 Console.WriteLine("请输入文件夹名称(例如:C:\Windows),输入quit结束程序");  
  68.                 FolderName = Console.ReadLine();  
  69.                 if (FolderName == "quit")  
  70.                     break;  
  71.                 d.BeginInvoke(FolderName, ShowFolderSize, FolderName);  
  72.             }  
  73.         }  
  74.     }  
  75. }  

Invoke() 调用时，会阻塞当前线程，等到 Invoke() 方法返回才继续执行后面的代码，表现出“同步”的概念。
BeginInvoke() 调用时，当前线程会启用线程池中的某个线程来执行此方法，当前线程不被阻塞，继续运行后面的代码，表现出“异步”的概念。
EndInvoke() ，在想获取 BeginInvoke() 执行完毕后的结果时，调用此方法来获取。
 
code：
 DevExpress.Utils.WaitDialogForm wf = new DevExpress.Utils.WaitDialogForm("请等待......", "正在导出到" + dlg.FileName, new Size(300, 80));
 DbfHelperDelegate d = new DbfHelperDelegate(dbf.CreateDBF);
 IAsyncResult ia = d.BeginInvoke(dlg.FileName, gridView, null, null);
  if (d.EndInvoke(ia))
      wf.Close();
 
文章转载地址：
http://m.blog.csdn.net/article/details?id=7971082&from=singlemessage
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/sunice/p/6843082.html