c# 闭包快多少？

一直想看看闭包是不是在初始化对象的时候是不是更快一些，今天刚好有时间用代码验证一下:

1. 环境

操作系统： Win8.1 (Build:9600)

CPU：I7-2610QM

内存：8G DDR2

硬盘：SSD

其他软件：VS2012 + .Net Framework 4.5 控制台程序。

2. 代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
namespace YourNameSpace
{
    public class Class1
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("---------First time----------");
            OrigninalWay();
            EnclosureWay();
            Console.WriteLine("---------Second time----------");
            OrigninalWay();
            EnclosureWay();

            Console.ReadLine();
        }

        public static void EnclosureWay()
        {
            Console.Write("EnclosureWay():");
            Stopwatch watch = new Stopwatch();
            List<Enclosure> list = new List<Enclosure>();
            Random random = new Random();
            watch.Start();
            
            for (int i = 0; i < 1000000; i++)
            {
                string value = random.Next(1000000, 9999999).ToString();
                list.Add(new Enclosure
                {
                    enclosure = value,
                    item1 = new Item1 { age = value, name = value },
                    item2s = new List<Item2>() { new Item2 { age2 = value, name2 = value }, new Item2 { age2 = value, name2 = value } }
                });
            }
            watch.Stop();
            Console.WriteLine(watch.ElapsedMilliseconds.ToString());
        }

        public static void OrigninalWay()
        {
            Console.Write("OrigninalWay():");
            Stopwatch watch = new Stopwatch();
            List<Enclosure> list2 = new List<Enclosure>();
            Random random = new Random();
            watch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                string value = random.Next(1000000, 9999999).ToString();
                // Assign enclosure
                Enclosure enclosure = new Enclosure();
                enclosure.enclosure = value;

                // Assign item1
                Item1 item1 = new Item1();
                item1.age = value;
                item1.name = value;
                enclosure.item1 = item1;

                // Assign item2s
                List<Item2> tempList = new List<Item2>();
                Item2 item2_1 = new Item2();
                item2_1.age2 = value;
                item2_1.name2 = value;
                Item2 item2_2 = new Item2();
                item2_2.age2 = value;
                item2_2.name2 = value;
                tempList.Add(item2_1);
                tempList.Add(item2_2);
                enclosure.item2s = tempList;

                list2.Add(enclosure);
            }
            watch.Stop();
            Console.WriteLine(watch.ElapsedMilliseconds.ToString());
        }
    }

    public class Enclosure
    {
        public string enclosure;
        public Item1 item1;
        public List<Item2> item2s;
    }

    public struct Item1
    {
        public string name;
        public string age;
    }

    public struct Item2
    {
        public string name2;
        public string age2;
    }
}

3. 结果：

4. 总结：

测试结果看起来没有明显差别，传统方式和闭包方式初始化性能基本不相上下。但是，没有验证过编译之后的中间代码是不是类似，所以暂时还不能下定论，待续.