c#中两种常用的异步调用方法

异步调用其实就是对线程的一种应用，但异步调用在使用上更加灵活，而且功能更强大。此外，异步调用还有一个的优点就是调用的是线程池里的线程（c#开发的应用程序的线程池里默认的线程数是25，如果要求调用线程池里的线程，而池里面的线程都是在使用的状态下时，外部请求会被放到一个队列里进行排队，等池里有空闲的线程时请求才被执行），开发者不用担心如何管理池里面的线程，直接调用即可。
下面列出两种最常用的异步调用的用法
一、没有回调函数的用法
定义委托：
private delegate void Asynchronism(List<string> list);
//调用
private void simpleButton1_Click(object sender, EventArgs e)
{ //实例化一个委托，开发中要传几个、什么类型的参数，在定义委托时就要指定好参数
Asynchronism Amethod = new Asynchronism(AsynchronismPrint);
//第一个参数是定义委托时定义好的参数及类型，第二个参数是要执行的回调函数，第三个是要参给回调函数的参数
IAsyncResult iresult= Amethod.BeginInvoke(m_alist, null,null);
//这一句作用是结束异步调用，可以放在异步调用之后的任务位置，但这种写法会引起主线程的阻塞，等异步调用执行完成后再继续往下执行
Amethod.EndInvoke(iresult);
//在主程序时执行的方法体
...
SynchronismPrint(m_list);
}
/// <summary>
/// 异步执行的方法:把传进来的列表里的数据打印出来
/// </summary>
/// <param name="list"></param>
private void AsynchronismPrint(List<string> list)
{
if (InvokeRequired)
{
BeginInvoke(new Asynchronism(AsynchronismPrint), new object[] { list });
return;
}
listBoxControl1.Items.Clear();
foreach (string s in list)
{
listBoxControl1.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}
}
/// <summary>
/// 主程序里执行的方法，作用是用来测试看是否与异步调用的方法同时执行
/// </summary>
/// <param name="list"></param>
private void SynchronismPrint(List<string> list)
{
listBoxControl2.Items.Clear();
foreach (string s in list)
{
listBoxControl2.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}
}
二、带回调函数的用法
private void simpleButton1_Click(object sender, EventArgs e)
{ //实例化一个委托，开发中要传几个、什么类型的参数，在定义委托时就要指定好参数
Asynchronism Amethod = new Asynchronism(AsynchronismPrint);
//实例化一个回调对象
AsyncCallback Acall = new AsyncCallback(Acallback);
//第三个参数提定了传给回调函数的参数，这是一个object类型，虽然只能传一个参数给回调函数，但可以传任类型的对象
Amethod.BeginInvoke(m_alist, Acall, Amethod);
//在主程序时执行的方法体
SynchronismPrint(m_list);
}

/// <summary>
/// 异步执行的方法
/// </summary>
/// <param name="list"></param>
private void AsynchronismPrint(List<string> list)
{
if (InvokeRequired)
{
BeginInvoke(new Asynchronism(AsynchronismPrint), new object[] { list });
return;
}
listBoxControl1.Items.Clear();
foreach (string s in list)
{
listBoxControl1.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}

}
/// <summary>
/// 回调函数，有且只有一个参数，但该参数可以传任何类型的object，通过异步调用时指定参数：Amethod.BeginInvoke(m_alist, Acall, Amethod);
/// </summary>
/// <param name="iAresult"></param>
private void Acallback(IAsyncResult iAresult)
{
//取得传入参数
Asynchronism result = iAresult.AsyncState as Asynchronism;
//结束回调调用
result.EndInvoke(iAresult);

}
/// <summary>
/// 主程序里执行的方法，作用是用来测试看是否与异步调用的方法同时执行
/// </summary>
/// <param name="list"></param>
private void SynchronismPrint(List<string> list)
{
listBoxControl2.Items.Clear();
foreach (string s in list)
{
listBoxControl2.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}
}

注：以下是测试实例的全部代码，在vs2008下运行通过
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace asynchronism
{
public partial class Form1 : Form
{
private List<string> m_alist = new List<string>();
private List<string> m_list = new List<string>();

private delegate void Asynchronism(List<string> list);

public Form1()
{
InitializeComponent();
for (int i = 0; i < 1000; i++)
{
m_alist.Add("AS"+i.ToString());
}
for (int j= 0; j < 1000; j++)
{
m_list.Add("S" + j.ToString());
}
}

private void simpleButton1_Click(object sender, EventArgs e)
{
Asynchronism Amethod = new Asynchronism(AsynchronismPrint);
AsyncCallback Acall = new AsyncCallback(Acallback);
Amethod.BeginInvoke(m_alist, Acall, Amethod);
//IAsyncResult iresult= Amethod.BeginInvoke(m_alist, null,null);
//labelControl3.Text = DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString();
//Amethod.EndInvoke(iresult);
SynchronismPrint(m_list);

}
/// <summary>
/// 异步执行的方法
/// </summary>
/// <param name="list"></param>
private void AsynchronismPrint(List<string> list)
{
if (InvokeRequired)
{
BeginInvoke(new Asynchronism(AsynchronismPrint), new object[] { list });
return;
}
listBoxControl1.Items.Clear();
foreach (string s in list)
{
listBoxControl1.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}

}
/// <summary>
/// 回调函数，有且只有一个参数，但该参数可以传任何类型的object，通过异步调用时指定参数：Amethod.BeginInvoke(m_alist, Acall, Amethod);
/// </summary>
/// <param name="iAresult"></param>
private void Acallback(IAsyncResult iAresult)
{
//取得传入参数
Asynchronism result = iAresult.AsyncState as Asynchronism;
//结束回调调用
result.EndInvoke(iAresult);

}
/// <summary>
/// 主程序里执行的方法，作用是用来测试看是否与异步调用的方法同时执行
/// </summary>
/// <param name="list"></param>
private void SynchronismPrint(List<string> list)
{
listBoxControl2.Items.Clear();
foreach (string s in list)
{
listBoxControl2.Items.Add(DateTime.Now.Second.ToString() + ":" + DateTime.Now.Millisecond.ToString() + "->" + s);
Application.DoEvents();
}
}
}
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/newzhhsh/archive/2008/09/25/2979905.aspx