本文主要是根据一个项目中遇到的异步的小例子，研究学习异步编程模型(APM)模式如何使用 BeginInvoke 与 EndInvoke。
在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下：
解决方案：
在软件启动后，软件页面正常完成加载后，后台继续进行异步加载资源文件，此时可操作正在加载的资源文件的按钮设置为不可操作。文件加载完成之后开发操作资源文件的按钮可操作。
具体实现如下：
1、WPF 页面 Window 中存在一个事件：ContentRendered。该事件在窗口的内容呈现完毕之后发生。定义一个方法，方法中进行文件加载的操作，并将该方法绑定到 ContentRendered 事件。
代码如下：
其中，LoadingResources() 方法为实际加载文件的方法；
ShowProgressBarFile 方法中具体实现异步，并更改页面按钮状态
private void Window_ContentRendered(object sender, EventArgs e)
{
//禁用对应的操作按钮
this.btnThreeView.IsEnabled = false;
Func<bool> action = (() => LoadingResources());
ShowProgressBarFile(action, "文件加载中...");
}
2、方法 LoadingResources()，实现文件加载的功能。
文件加载使用多线程编程。一个线程为真加载线程，加载对应的资源文件，文件完成加载后，对应页面的操作按钮放开显示；
一个线程为假加载线程，可以用于加载进度条显示在页面。
具体详细的学习和分析见文章：
C#异步编程案例学习——异步加载大资源文件 2 之 多线程加载
private bool LoadingResources()
{
//......实现具体文件加载
Thread t1 = new Thread(new ThreadStart(loadReal)); //loadReal 是真线程加载
t1.Name = "真加载线程";
t1.IsBackground = false;
Thread t2 = new Thread(new ThreadStart(loadNotTrue)); //loadNotTrue 是假线程加载
t2.Name = "假加载线程";
t2.IsBackground = true;
t1.Start();
t2.Start();
while (trueLoad == 0 && falseLoad == 0)
{
//阻塞
}
//下面的代码是在完成加载后，屏蔽页面假线程加载显示的进度条信息
this.pb_info.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
{
this.pb_info.Visibility = Visibility.Collapsed;
});
this.pb_test.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
{
this.pb_test.Visibility = Visibility.Collapsed;
});
return true;
}
3、方法ShowProgressBarFile 实现异步：
其中，func.BeginInvoke 开启异步；
asyncResult.IsCompleted 用于检查异步方法是否执行完成；
func.EndInvoke 结束异步。
这种异步编程的方法叫做“异步编程模型(APM)模式”
private bool ShowProgressBarFile(Func<bool> func, string text)
{
var asyncResult = func.BeginInvoke(null, null);
while (!asyncResult.IsCompleted)
{
System.Windows.Forms.Application.DoEvents();
}
return func.EndInvoke(asyncResult);
}
.NET Framework 中提供了执行异步操作的 3 种模式：
APM 和 EAP 两种模式是早期版本引入的，.Net 4 版本之后，Visual Studio 建议对于新的开发工作不再使用它们。对于 TAP 在《C#异步编程学习笔记》的文章中有相关学习笔记，后续详细学习使用后补充学习博客。
本文主要介绍的 BeginInvoke 与 EndInvoke 方式是基于 APM 的。.net中有很多类实现了该模式(比如HttpWebRequest)，同时我们也可以自定义类来实现APM模式(继承IAsyncResult接口并且实现BeginXXX和EndXXX方法)。
如果委托对象的调用列表中只有一个方法（引用方法），就可以异步执行这个方法，通过调用委托类特有的两个方法 BeginInvoke 和 EndInvoke 去执行。
当我们调用委托的 BeginInvoke 方法时，它开始在一个独立线程上执行引用方法，并且立即返回到原始线程。原始线程可以继续，而引用方法会在线程此的线程中并行执行。
当程序希望获取已完成的异步方法的结果时，可以检测 BeginInvoke 返回的 IAsyncResult 的 IsCompleted 属性，或调用委托的 EndInvoke 方法来等待委托完成。
IAsyncResult BeginInvoke(-------,AsyncCallback callback,object state)
当调用委托的BeginInvoke方法时，系统会创建一个AsyncResult类对象， BeginInvoke方法执行完后，方法返回属于AsyncResult类对象中的一个IAsyncResult接口类型的引用。IAsyncResult 是使用 BeginInvoke 和 EndInvoke 方法的必要部分。
在这种模式里，原始线程发起一个异步方法的调用，做一些其它处理，然后停止并等待，直到开启的线程结束。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace waitModel
{
// 1、声明一个委托
delegate int MyDel(int x, int y);
class Program
{
static int sum(int x,int y) //异步方法
{
Console.WriteLine("inside sum");
Thread.Sleep(8000);
return x+y;
}
static void Main(string[] args)
{
// 2、创建委托变量
// 3、为委托绑定一个方法
MyDel Del = new MyDel(sum);
Console.WriteLine("Before BeginInvoke");
// 4、异步调用委托。
// 开始异步执行，封装回调函数：BeginInvoke(参数，回调函数，回调函数多需的对象/参数)
IAsyncResult iresult = Del.BeginInvoke(4,6,null,null); //开始异步执行
Console.WriteLine("After BeginInvoke"); //程序在执行异步方法的同时，执行该语句
Console.WriteLine("Doing something");
int result = Del.EndInvoke(iresult); //等待，直到异步方法执行完毕，将结果
Console.WriteLine("After EndInvoke, result = {0}",result);
Console.ReadKey();
}
}
}
异步操作代码实现一般需要经过以下四个步骤，这四个步骤适用于等待模式和轮询模式。
如上四个步骤均在等待模式和轮询模式的代码中标注
在轮询模式中，原始线程发起了异步方法的调用，做一些其它处理，然后使用 IAsyncResult 对象的 IsCompleted 属性来定期检查开启的线程是否完成。如果异步方法已经完成，原始线程就调用 EndInvoke 并继续。否则，它做一些其它处理，然后过一会儿再检查。
轮询模式与等待模式相比，只增加了一步：通过检查 IAsnyResult 接口对象的 IsComplete 属性的判断异步方法是否完成，如没完成，在检查过程中可以做其它事情。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
//轮询模式与等待一直完成模式相比只增加了iresult.IsCompleted判断是否完成的步骤
namespace polling
{
class Program
{
// 1、声明一个委托
delegate int MyDel(int x,int y);
static int sum(int x, int y)
{
Console.WriteLine("insid sum");
Thread.Sleep(1000);
return x + y;
}
static void Main(string[] args)
{
// 2、创建委托变量
// 3、为委托绑定一个方法
MyDel Del = new MyDel(sum);
Console.WriteLine("Before BeginInvoke");
// 4、异步调用委托
IAsyncResult iresult = Del.BeginInvoke(2,3,null,null); //发起异步调用
Console.WriteLine("After BeginInvoke");
while (!iresult.IsCompleted) //检测IAsyncResult接口的IsCompleted属性判断异步方法是否完成
{
Console.WriteLine("Sum Not Complete");
Thread.Sleep(1000);
}
Console.WriteLine("Sum Completed.");
int result = Del.EndInvoke(iresult); //异步方法执行完后才会执行这一句
Console.WriteLine("Result: {0}",result);
Console.ReadKey();
}
}
}
上面使用等待和轮询模式的方式需要等待。等待是个让人很恼火的事情。.Net考虑了这一点，为我们准备了回调的方式：你异步调用后继续干你的事儿，等你执行完后，你告我一声就ok了。
回调模式的不同之处在于，一旦主线程线程发起了异步方法，它就自己管自己了，不再考虑异步方法是否执行完成，当异步方法执行完后，系统会通过调用一个回调方法处理异步方法的结果，和调用委托的 EndInvoke 方法。
回调方法：回调方法的返回类型为void，以一个IAsyncResult接口类型的参数做为形参：
void AsyncCallback(IAsyncResult iresult)
上文提到 BeginInvoke方法的参数意义
IAsyncResult BeginInvoke(-------,AsyncCallback callback,object state)
回调方法和BeginInvoke方法是通过BeginInvoke方法内部的最后两个参数关联的
两种方法为BeginInvoke方法第一个参数赋值：
回调模式是在回调方法内部，通过调用委托的 EndInvoke 方法来处理异步方法返回的结果，释放线程所占用的资源，而等待模式和轮询模式是在主线程中调用的；
要调用委托的EndInvoke方法，必须要有委托的引用，在回调方法内部，先是将回调方法的 IAsyncResult 接口类型通过里氏转换转换为 AsyncResult 类类型，然后再调用 AsyncResult 类的 AsyncDelegate 属性转化为合适的委托类型。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace callback
{
delegate int Mydel(int x,int y);
class Program
{
static int sum(int x,int y) //异步方法
{
Console.WriteLine(" InSide Sum1");
Thread.Sleep(1000);
Console.WriteLine(" InSide Sum2");
return x + y;
}
//回调模式是在回调方法内部，通过调用委托的EndInvoke方法来处理异步方法返回的结果，释放线程所占用的资源而等待直到完成模式和轮询模式是在主线程中调用;
//要调用委托的EndInvoke方法，必须要有委托的引用，在回调方法内部,先是将回调方法的IAsyncResult接口类型通过里氏转换转换为AsyncResult类类型，
//然后再调用AsyncResult类的AsyncDelegate属性转化为合适的委托类型
static void callback_(IAsyncResult iar) //回调方法 无论如何回调方法中的内容必须在异步方法执行完后才执行
{
Console.WriteLine(" Inside CallWhenDone");
AsyncResult ar = (AsyncResult)iar; //里氏转换，如果父类中装的是子类的对象，那么可以将这个父类转换为子类对象
Mydel del = (Mydel)ar.AsyncDelegate; //通过AsyncResult类对象的AsyncDelegate属性转化为合适的Mydel委托类型
long result = del.EndInvoke(iar);
Console.WriteLine(" The result is: {0}",result);
}
static void Main(string[] args)
{
Mydel Del = new Mydel(sum);
Console.WriteLine("Before BeginInvoke");
IAsyncResult iar = Del.BeginInvoke(7,8,new AsyncCallback(callback_),Del); //Del焕成null结果也一样
Console.WriteLine("Doing more work in main");
Thread.Sleep(500);
Console.WriteLine("Done with Main.Exiting");
Console.ReadKey();
}
}
}
异步操作代码（回调模式）相较于前面的增加了一个回调，这三个步骤适用于等待模式和轮询模式。
//【1】声明一个名为Operation的委托，并交代执行方法
// 这里完成了1. 声明一个委托类型；2. 创建委托类型的变量；3. 为委托绑定一个方法
//int:传入参数 string：返回值
public Func<int, string> Operation = (num) =>
{
Thread.Sleep(num * 1000);
return num.ToString();
};
private void button1_Click(object sender, EventArgs e)
{
//【2】异步调用
IAsyncResult str = Operation.BeginInvoke(2, CallBack, "发送给回调函数的参数");
}
//【3】回调函数
public void CallBack(IAsyncResult result)
{
string res = Operation.EndInvoke(result); //返回结果（结果类型，与委托返回值类型一致）
var v = result.AsyncState; //获取传递给回调函数的参数
}
笔记参考：
http://www.cnblogs.com/zwt-blog/p/4812530.html#3611906
https://blog.csdn.net/ABC13222880223/article/details/85317621