老趙點滴 - 追求編程之美 先做人，再做技術人員，最后做程序員。打造國內最好的.NET技術博客。

firelong雄文又起，不過說實話，可能是這篇文章寫的太簡單了，其中的理由和結論都聽得不是很明白。當然有一段話的意思很清楚（原話）：“C#事件的背后是一個委托鏈表（單鏈表），單鏈表的遍歷調用性能遠低于數組鏈表（List）”。這句話讓我比較納悶，因為從我的直覺來說，兩種做法之間即使性能有差距，也不該是“遠高于”啊。不過我提出這個疑問之后，firelong回應到（還是原話）“間接指針移動，和i++哪個快慢很難辨析嗎？”于是我想，還是做個試驗吧。

firelong雄文又起，不過說實話，可能是這篇文章寫的太簡單了，其中的理由和結論都聽得不是很明白。當然有一段話的意思很清楚（原話）：“C#事件的背后是一個委托鏈表（單鏈表），單鏈表的遍歷調用性能遠低于數組鏈表（List<T>）”。這句話讓我比較納悶，因為從我的直覺來說，兩種做法之間即使性能有差距，也不該是“遠高于”啊。不過我提出這個疑問之后，firelong回應到（還是原話）“間接指針移動，和i++哪個快慢很難辨析嗎？”于是我想，還是做個試驗吧。試驗代碼很簡單：

public class Node
{
    public Node Next;
    public int Value;
}

public class Item
{
    public int Value;
}

class Program
{
    static Node GetSingleList(int length)
    {
        Node root = null;
        for (int i = 0; i < length; i++)
        {
            root = new Node { Next = root, Value = 0 };
        }

        return root;
    }

    static List<Item> GetList(int length)
    {
        return Enumerable.Range(0, length)
            .Select(_ => new Item { Value = 0 }).ToList();
    }

    static void Main(string[] args)
    {
        int length = 10000;
        int iteration = 100000;
        int count = 0;

        var root = GetSingleList(length);
        var watch1 = Stopwatch.StartNew();
        for (int t = 0; t < iteration; t++)
        {
            var node = root;
            while (node != null)
            {
                count += node.Value;
                node = node.Next;
            }
        }
        Console.WriteLine("{0} (Node List)", watch1.Elapsed);

        GC.Collect();

        var list = GetList(length);
        var watch2 = Stopwatch.StartNew();
        for (int t = 0; t < iteration; t++)
        {
            for (int i = 0; i < list.Count; i++)
            {
                count += list[i].Value;
            }
        }
        Console.WriteLine("{0} (List<Item>)", watch2.Elapsed);
    }
}

使用Release模式編譯，并且保證VS不會Attach Debugger之后，執行幾遍結果如下：

00:00:02.0731861 (Node List)
00:00:02.4602990 (List<Item>)

00:00:02.3176291 (Node List)
00:00:02.2912638 (List<Item>)

00:00:02.1539642 (Node List)
00:00:02.4635390 (List<Item>)

我的直覺是這樣的：如果使用List<T>來遍歷，除了i++操作以外，還需要計算偏移量，根據List內部的數組來找到下一個對象的地址，再根據這個地址去訪問下一個對象，而單向鏈表的遍歷做的事情會少一些，只要一個接一個的訪問就行了。從結果上看，總體說來差別不大，并沒有出現firelong所說的“單向鏈表遍歷性能遠低于List<T>”的情況出現。而且事實上，這點性能真的有關系嗎？這里累計遍歷了10億個元素，才產生了零點幾秒的差距，而對于一個事件來說，您會為它添加多少個Handler，又會調用多少次呢？

我一直不愿意多談性能方面的問題，因為我實在沒有什么可談的，該談的都談過了。而且，我在這方面也沒吃過什么苦頭，即使遇到一些小問題，也是因為代碼寫的效率不高，簡單優化以后就沒有問題了。不過firelong的新文章談的是設計，例如覺得C#——應該說是.NET的事件機制很糟糕，yield功能沒有什么用，讓C#語法變的很臃腫等等。我喜歡語言，我很喜歡談語言設計，所以這些方面倒有可以討論的地方。只是最近事情有些多，以后我會寫的，您可以關注我的新博客。

這篇文章寫的比較匆忙，也沒有什么太可取的內容，便先簡單試試看這趟水有多深吧。

補充說明三點：

有朋友提出，數組里的對象在內存里的分布是連續的，單向鏈表不連續，因此考慮到如果換頁，緩存等關系，基于數組的效率會比較高。我的看法是：如果您遍歷的是int[]，那么每個int值的在內存里自然是連續的，但是這里訪問的是Item[]這樣的引用元素的數組，連續分布的只是對象的地址，而要獲得最終對象，還得再根據地址去訪問某個內存，它就不能保證連續性了。同樣道理，有朋友說，真實情況下Node這樣的對象不是連續訪問的，我認為這個差別也不會偏袒向其中任何一方。也有朋友認為，不管怎么說數組里的地址是連續的，局部性還是更好。不過我認為，對于單向鏈表來說，如訪問Node的Value時，Next也會一并加載到緩存里去，同一個對象的字段是緊挨著的也是.NET出于局部性的考慮。

還有朋友指出，數組訪問它不會傻傻得i++再去訪問下標，它會優化。這沒錯，如果您用Item[]來代替List<Item>就會發現性能的確有提高（但同樣相差不大）。但是，firelong同學說的是List<T>，它不是數組，而是基于數組的容器。由于List<T>是可變的，因此JIT是否真會對其進行優化還是個未知數，我傾向于理解為“不是”。不過現在，我只是通過小實驗來看看究竟相差如何。

也有朋友說，Delegate不一定就是用單向鏈表或是List<T>保存的啊。是的，已經有朋友在firelong的原帖提出了。不過我針對的只是firelong關于“單項鏈表和List<T>”之間的遍歷性能比較。我一直很奇怪，firelong從上一篇就開始說“性能相差很大”，“遠低于”，“致命影響”之類的很嚴重的詞匯，但是真的嚴重到什么程度卻始終不給出任何說法。因此我現在也只是開個頭，想說明firelong一些說得的很嚴重的事情，大家還得自己考證一下。