1.c#异步介绍
异步必须基于委托，有委托才有异步
新建一个window Form程序MyAsync，添加一个按钮，（name）=btnAsync
后台代码如下：
using System;
using System.Windows.Forms;
using System.Threading;
namespace MyAsync
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private delegate void DoSomethingHandler(string name);//定义一个委托函数
private void btnAsync_Click(object sender, EventArgs e)//btnAsync的点击事件
{
DoSomethingHandler method = new DoSomethingHandler(DoSomething);
for (int i = ; i <= ; i++)
{
string name = string.Format("Async_{0}", i);
method.BeginInvoke(name, null, null);//新建一个子线程，异步调用
}
}private void DoSomething(string name)//调用函数
{
Console.WriteLine("{0}正在执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep();
Console.WriteLine("{0}结束执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
}
}
}
ps:在window Form，我们可以把启动项目的输出类型改成——控制台应用程序，这样在点击事件时，可以看到代码的执行过程
如：
执行结果：
异步调用特点：无序、高效、线程并发
2.异步进阶:对BeginInvoke(name, null, null)参数的了解
第一个参数：委托函数的参数
第二个参数：AsyncCallback类型的参数，表示异步回调，只有执行完调用函数，才会去执行回调函数
第三个参数：object类型的参数，用于给回调函数传参，在回调函数使用 [回调函数的参数名].AsyncState 可以使用这个参数，如以下代码的result.AsyncState
using System;
using System.Windows.Forms;
using System.Threading;
namespace MyAsync
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private delegate void DoSomethingHandler(string name);//调用函数的委托
//public delegate void AsyncCallback(IAsyncResult ar);//回调委托，在AsyncCallback上查询定义可以查到，不能在这块重复定义
private void btnAsync_Click(object sender, EventArgs e)
{
DoSomethingHandler method = new DoSomethingHandler(DoSomething);//声明两个委托
AsyncCallback asyncCallback = new AsyncCallback(ThreadCallback);
for (int i = ; i <= ; i++)
{
string name = string.Format("Async_{0}", i);
method.BeginInvoke(name, asyncCallback, "param");//执行完委托的DoSomething方法后才执行回调函数ThreadCallback
}
}
private void ThreadCallback(IAsyncResult result)//回调函数
{
Console.WriteLine("{0}执行了ThreadCallback,参数有{1}", Thread.CurrentThread.ManagedThreadId,result.AsyncState);
}
private void DoSomething(string name)//调用函数
{
Console.WriteLine("{0}正在执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep();
Console.WriteLine("{0}结束执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
}
}
}
扩展：当我们把method.BeginInvoke赋值给一个变量的时候，这个变量代表的就是回调函数的参数（为了方便观察，这里去掉了循环，并修改了btnAsync_Click事件）
private void btnAsync_Click(object sender, EventArgs e)
{
DoSomethingHandler method = new DoSomethingHandler(DoSomething);
AsyncCallback asyncCallback = new AsyncCallback(ThreadCallback);
string name = "Async_{0}";
IAsyncResult result= method.BeginInvoke(name, asyncCallback, "param");//执行完委托的DoSomething方法后才执行回调函数ThreadCallback
Console.WriteLine(result.AsyncState);
}
通过这个结果，我们可以看到，1代表是并不是这个函数的返回结果，而是输入参数，即1和2是等价的，是由3中两个参数决定的（我也知道这个很神奇）
而且，因为是异步请求，BeginInvoke新开的一个子线程和主线程是同时进行的，所以Console.WriteLine(result.AsyncState);可以先被执行，即先打印了param
3.带返回值的异步调用
修改调用函数，使其有return
在调用函数被修改后，调用函数委托也得修改
method.EndInvoke(result)方法可以接收返回值，result是IAsyncResult类型，也就是上图的1
因为1与2等价，所以在回调函数里面也可以使用method.EndInvoke(result)查看调用函数的返回值（使用lambda表达式，不然无法使用method，下面代码的红字），还有一次异步调用只能使用一次method.EndInvoke(result)
method.EndInvoke(result)方法必须等调用函数执行完才能执行，当调用函数还没return时会卡住界面，即卡住主线程
using System;using System.Windows.Forms;
using System.Threading;
namespace MyAsync
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private delegate int DoSomethingHandler(string name);
private void btnAsync_Click(object sender, EventArgs e)
{
DoSomethingHandler method = new DoSomethingHandler(DoSomething);
AsyncCallback asyncCallback = new AsyncCallback(ThreadCallback);
string name = "Async";
IAsyncResult result=method.BeginInvoke(name, asyncCallback, "param");//执行完委托的调用函数DoSomething后才执行回调函数ThreadCallback
//--------------------如果这里有代码，是可以和BeginInvoke新开的子线程同步执行的----------------//
//-------但是执行到EndInvoke的时候，若是调用函数还没执行完，无法进行下一步，会卡住界面---------//
while (!result.IsCompleted)
{
Console.WriteLine("调用函数还没执行完，请耐心等待....");
Thread.Sleep();//每0.5秒打印一次
}
//-------------可以使用IsCompleted判断是否执行完毕，避免用户以为卡机，关闭程序------------------//
int i = method.EndInvoke(result);//等调用函数执行完才会执行
Console.WriteLine("这里是返回值={0}",i);
}
private void ThreadCallback(IAsyncResult result)//回调函数
{
Console.WriteLine("{0}执行了ThreadCallback,参数有{1}", Thread.CurrentThread.ManagedThreadId,result.AsyncState);
}
private int DoSomething(string name)//调用函数
{
Console.WriteLine("{0}正在执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep();
Console.WriteLine("{0}结束执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
return ;
}
}
}
结果：
4.扩展：使用lambda
using System;using System.Windows.Forms;
using System.Threading;
namespace MyAsync
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private delegate int DoSomethingHandler(string name);
private void btnAsync_Click(object sender, EventArgs e)
{
DoSomethingHandler method = new DoSomethingHandler(DoSomething);
//AsyncCallback asyncCallback = new AsyncCallback(ThreadCallback);//使用lambda后可删除回调委托和回调函数
string name = "Async"; method.BeginInvoke(name, t=>
{//回调函数
Console.WriteLine("{0}执行了ThreadCallback,参数有{1}", Thread.CurrentThread.ManagedThreadId, t.AsyncState);
int i = method.EndInvoke(t);//回掉函数内部打印返回值
Console.WriteLine("这里是返回值={0}", i);
}, "param");
}
//private void ThreadCallback(IAsyncResult result)//使用lambda后可删除回调委托和回调函数
//{
// Console.WriteLine("{0}执行了ThreadCallback,参数有{1}", Thread.CurrentThread.ManagedThreadId,result.AsyncState);
//}
private int DoSomething(string name)//调用函数
{
Console.WriteLine("{0}正在执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep();
Console.WriteLine("{0}结束执行,线程ID={1}", name, Thread.CurrentThread.ManagedThreadId);
return ;
}
}
}
结果：
这个时候因为method.EndInvoke是在回调函数里面使用的，回调函数又是由子线程执行的，所以只会卡住子线程，主线程并不会被卡住，即界面不会卡住
而且method.EndInvoke对于每个异步操作只能执行一次，如果在子线程和主线程都出现，会报错
当然，只在子线程或者主线程出现多次也会报错
5.使用Task框架实现异步
添加一个新按钮 （name）= AsynsTask
using System;using System.Windows.Forms;
using System.Threading;
namespace MyAsync
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}private void AsynsTask_Click(object sender, EventArgs e)
{
Console.WriteLine("接到任务");
Console.WriteLine("分配任务，用多线程同时进行任务，模拟实际开发中团队同时进行");
TaskFactory taskFactory = new TaskFactory();//实例化一个TaskFactory任务工厂
Action act1 = new Action(() => Coding("kxy", "后台"));//用lambda表达式表示一个无参数无返回值的匿名函数
Action act2 = new Action(() => Coding("fz", "后台"));
Action act3 = new Action(() => Coding("xx", "数据库"));
Action act4 = new Action(() => Coding("flt", "前端"));
Action act5 = new Action(() => Coding("zjx", "前端"));
Task task1 = taskFactory.StartNew(act1);//Task创建并开启一个线程,执行act
Task task2 = taskFactory.StartNew(act2);
Task task3 = taskFactory.StartNew(act3);
Task task4 = taskFactory.StartNew(act4);
Task task5 = taskFactory.StartNew(act5);
List<Task> Ltask = new List<Task>();
Ltask.Add(task1);
Ltask.Add(task2);
Ltask.Add(task3);
Ltask.Add(task4);
Ltask.Add(task5);
Task.WaitAny(Ltask.ToArray());//等待这些线程中某一个执行完再往下执行主线程
Console.WriteLine("<<<开始进行测试>>>");
Task.WaitAll(Ltask.ToArray());//等待这些线程执行完成再往下执行主线程
Console.WriteLine("<<<开发完成,开始部署>>>");
Console.WriteLine("<<<任务完成>>>");
}
private void Coding(string name, string work)
{
Console.WriteLine("线程ID={0} {1} 的工作是 {2}", Thread.CurrentThread.ManagedThreadId, name, work);
Thread.Sleep();
Console.WriteLine("============线程ID={0} {1} 完成工作 {2}", Thread.CurrentThread.ManagedThreadId, name, work);
}
}
}