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一些说得的很严重的事情，大家还得自己考证一下。