最近在写一个导数据的程序，需要从几个老数据表中取出n多的数据，然后加以处理再添加到新数据库的对应表中。单步操作太慢了，这不正是多线程的用武之地吗？

对于每一种数据我都得写一套类似的代码，表意代码如下

由于老数据有n种，每一种的处理方法又不一样，所以我写了n个类似上面的处理步骤，这太累了吧，于是想重构，将上面的操作步骤中相同的地方提取出来。于是有了AsyncHelper静态类，这个静态类有几个公开的静态方法来做上面那些分多个线程处理大量数据的步骤中一样的过程。

第一个方法的签名应该是这样子的

大量的数据定义一个IList类型的类作为参数传递，要分多少个线程来处理这些数据用threadCn指定，需要注意的是WaitHandle.WaitAll方法决定了threadCn必须小于64，最后一个参数是处理大量数据中的一个数据的方法。方法的签名出来了，我在上面又做了几次重复的处理，写这个方法应该不是个问题。同样的我们也是需要把IList数据分成threadCn份，然后将每一份都交给ThreadPool来处理，这很简单。

这个很容易实现，不过既然要做封装我们就不得不多考虑一些，我们的线程好比是一个一个的侦查兵，这次给他们的任务是抓一个敌人回来问问敌情，任务要求只抓一个敌人，也就是说如果某一个侦查兵抓到一个敌人之后要给其他战友发信息，告诉他们别忙了，任务已经完成了。这个该怎么办呢，办法总是要比问题多的。

WaitHandle类有WaitAny静态方法，上面侦察兵的例子不就是个WaitAny吗，主线程需要在接受到一个线程完成的信号后通知所有线程，“任务完成了，大家都回家吧”？大家如果有兴趣的话，可以给出自己的方案，我的方案明天放出来。明天一并要解决的还有取得多个执行操作的返回值问题。

我们需要解决WaitAny和取得异步执行的返回值的问题。地球人都知道Thread和ThreadPool接受的委托都是没有返回值的。要想取的返回值，我们就得自己动手了，我们需要构造一个AsyncContext类，由这个类来保存异步执行的状态以并存储返回值。

代码如下：

如何使用AsyncHelper类，请看下面的测试代码：

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using AppUtility;
using System.IO;
using System.Collections;
using System.Threading;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            /*
            List<string> testFiles = new List<string>();
            for (int i = 0; i < 100; i++)
            {
                testFiles.Add(“D:\\test\\async\\file_” + i.ToString() + “.log”);
            }
            AsyncHelper.DoAsync(testFiles, 10, WriteFile);

            Console.WriteLine(“异步写耗时”+sw.ElapsedMilliseconds + “ms”);
            */

            List<string> testFiles = new List<string>();
            for (int i = 0; i < 200; i++)
            {
                testFiles.Add(“D:\\test\\async\\file_” + i.ToString() + “.log”);
            }
           
            Hashtable result;

            AsyncHelper.DoAsync(testFiles, 20, WriteFileAndReturnRowCount,false,out result);

            Console.WriteLine(“异步写耗时” + sw.ElapsedMilliseconds + “ms”);

            Thread.Sleep(10);

            if (result != null)
            {
                foreach (object key in result.Keys)
                {
                    Console.WriteLine(“{0}={1}”,  key,result[key]);
                }

            }

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 200; i++)
            {
                WriteFile(“D:\\test\\sync\\file_” + i.ToString() + “.log”);
            }

            Console.WriteLine(“同步写耗时” + sw.ElapsedMilliseconds + “ms”);

            Console.Read();
        }

        static void WriteFile(object objFilePath)
        {
            string filePath = (string)objFilePath;
            string dir = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            //Random r = new Random(DateTime.Now.Minute);
            int rowCn = 10000;
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.Default))
            {
                for (int i = 0; i < rowCn; i++) writer.WriteLine(Guid.NewGuid());
            }
        }

        static object WriteFileAndReturnRowCount(object objFilePath)
        {
            string filePath = (string)objFilePath;
            string dir = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            //Random r = new Random(DateTime.Now.Minute);
            int rowCn = 10000;
            using (StreamWriter writer = new StreamWriter(filePath, false, Encoding.Default))
            {
                for (int i = 0; i < rowCn ; i++) writer.WriteLine(Guid.NewGuid());
            }
            return DateTime.Now.ToLongTimeString();
        }
    }
}