最近写了几篇《c#扩展方法奇思妙用》的文章，一直只是讨论如何扩展、如何使用的问题，几乎没有涉及效率方面。
而大家的回复好多都在问效率如何、性能怎样，也引起了我对效率的关注，今天将初步测试的结果发出来，大家一起探讨一下。

以前没太写过性能测试的代码，上网找了一下，说可以用Stopwatch进行计时，比较准确。
Stopwatch使用比较简单，几个方法从名字上就知道用用途：Reset(计时清零)、Start(开始计时)、Stop(停止计时)，属性ElapsedMilliseconds就是执行操作所用的毫秒数。

为了简化测试，让更多人看明白，我们这是对IsNullOrEmpty扩展进行测试，它只是简单调用string.IsNullOrEmpty静态方法。
但为了让我们的测试更有趣一些，我们再加上两个相同功能的方法，一个是IsNullOrEmpty的手工实现版，称为手工方法，另外一个用lambda表达式写的。
一共是如下三个方法与string.IsNullOrEmpty（称为“原方法”）比较：

 1         //扩展方法
 2         public static bool IsNullOrEmpty1(this string s)
 3         {
 4             return string.IsNullOrEmpty(s);
 5         }
 6         //手工方法
 7         public static bool IsNullOrEmpty2(string s)
 8         {
 9             return s == null || s == string.Empty;
10         }
11         //lambda方法
12         public static Func<string, bool> IsNullOrEmpty3 = s => string.IsNullOrEmpty(s);

我们在函数名后面添加上一个数字，将它们区分开，以避免相互混淆。

为了测试公正，尽量消除测试中的误差，我们采用一个数组存放要测试的字符串。
这个数组中存放三种字符串，非Empty非Null、Empty、Null。随机存入，数量大致相同。生成算法如下:

 1         private static string[] GetTestStringArray(int count)
 2         {
 3             string[] result = new string[count];
 4             Random random = new Random();
 5 
 6             int r = 0;
 7             for (int i = 0; i < count; i++)
 8             {
 9                 r = random.Next(3);
10                 if (r == 0) result[i] = i.ToString();
11                 else if (r == 1) result[i] = string.Empty;
12                 else result[i] = null;
13             }
14             return result;
15         }

我们让这四个算法（前面三个算法+原来的静态算法）依次对数组中的每一项进行判断。
有一点要特别注意，对集合遍历也要耗时，我们要排除这段时间。
下面给出测试算法，写的不好，别见笑：

 1public static void Test()
 2{
 3    int count = 10000000;                                 //7个零
 4    string[] ss = GetTestStringArray(count);  //测试字符串Array
 5    bool b;
 6    string str;
 7
 8    long t = 0;    //基本循环时间
 9    long t0 = 0;    //原方法时间
10    long t1 = 0;    //扩展方法时间
11    long t2 = 0;    //手工方法时间
12    long t3 = 0;    //lambda时间
13
14    Stopwatch watch = new Stopwatch();
15    for (int i = 0; i < 10; i++)    //循环测试10次
16    {
17        watch.Reset(); watch.Start();
18        foreach (string s in ss) str = s;
19        watch.Stop();
20        Console.Write("基本循环：" + watch.ElapsedMilliseconds + "ms\t\t\t\t");
21        t += watch.ElapsedMilliseconds;
22
23        watch.Reset(); watch.Start();
24        foreach (string s in ss) { str = s; b = string.IsNullOrEmpty(str); }
25        watch.Stop();
26        Console.Write("原方法：" + watch.ElapsedMilliseconds + "ms\t\t");
27        t0 += watch.ElapsedMilliseconds;
28
29        watch.Reset(); watch.Start();
30        foreach (string s in ss) { str = s; b = str.IsNullOrEmpty1(); }
31        watch.Stop();
32        Console.Write("扩展方法：" + watch.ElapsedMilliseconds + "ms\t\t");
33        t1 += watch.ElapsedMilliseconds;
34
35        watch.Reset(); watch.Start();
36        foreach (string s in ss) { str = s; b = IsNullOrEmpty2(str); }
37        watch.Stop();
38        Console.Write("手工方法：" + watch.ElapsedMilliseconds + "ms\t\t");
39        t2 += watch.ElapsedMilliseconds;
40
41        watch.Reset(); watch.Start();
42        foreach (string s in ss) { str = s; b = IsNullOrEmpty3(str); }
43        watch.Stop();
44        Console.Write("lambda方法：" + watch.ElapsedMilliseconds + "ms\t\t");
45        t3 += watch.ElapsedMilliseconds;
46
47        Console.WriteLine();
48    }
49
50    Console.WriteLine();
51
52    Console.WriteLine(string.Format("扩展方法\t / 原方法\t = {0:f2}", (t1 - t) * 1.0 / (t0 - t)));
53    Console.WriteLine(string.Format("手工方法\t / 原方法\t = {0:f2}", (t2 - t) * 1.0 / (t0 - t)));
54    Console.WriteLine(string.Format("lambda方法\t / 原方法\t = {0:f2}", (t3 - t) * 1.0 / (t0 - t)));
55}
56

想重构一下，考虑了几种办法，不太好，怕重构后大家看起来更费力。

Test中的4个小段代码很相似，分别用来测量4个算法的用时。

1     foreach (string s in ss) str = s;