读FCL源码系列之List<T>---让你知其所以然---内含疑问求大神指点

序言

　　在.NET开发中，List<T>是我们经常用到的类型。前段时间看到其他部门小伙伴讨论“两个List（10W个元素）集合求并集，list1.Where(p=>list2.Contains(p)).ToList()”，性能很差，有人说是ToList的问题，我当时第一直觉是关键在Contains方法，这个问题后面在来细说讨论。还有某大神说过，没反编译过框架源码的码农不是合格码农:)。下面我们就借助Reflector来读一读.NET4.0中List<T>的源码，在读到一些方法实现时候，会更清楚，oh，原来是这样，解开以前的疑惑，写更有效率的代码。

List<T>的数据成员

private const int _defaultCapacity = 4;
        private static readonly T[] _emptyArray;
        private T[] _items;
        private int _size;
        [NonSerialized]
        private object _syncRoot;
        private int _version;

　　根据读整个类的代码，简单解释下：

_defaultCapacity：表示默认的初始容量，即内部容器数组的Length。但在ctrl+f搜索不到有该字段的使用，有点奇怪（代码中都是写死的4），于是查看IL后，发现是static literal string str="123".我们都知道const是在编译期必须初始化值。const字段的本质是static，那么它同样具备Type Dictionary，但我们无法通过像下面的验证，因为它在编译时必须初始化，值确定了。

    class Test<T>
    {
        //public const string _defaultCapacity="123";
        public static string Address;
        static Test()
        {
            Address = typeof(T).ToString();
        }
        
    }
    class MyList
    {
         static void Main()
        {
           // Console.WriteLine("const :{0}",object.ReferenceEquals(Test<int>._defaultCapacity, Test<string>._defaultCapacity));
            Console.WriteLine("static :{0}", object.ReferenceEquals(Test<int>.Address, Test<string>.Address));//false
            //Console.WriteLine(Test<string>._defaultCapacity);
        }
    }

　　但是反编译的代码中没有对_defaultCapacity使用，代码中是写死4的，难道在编译时候对所以使用的地方都替换成了4？为什么要定义为const而不用static，大神您怎么看？

_emptyArray：默认为一个空数组，在静态构造函数中初始化。为什么不这样写public static readonly T[] _emptyArray=new T[0];效果是一样的。大神您怎么看？

_items：这个真正存储数据的内部数组。

_size：表示List中存储元素的个数。

_syncRoot：用于Thread Safe的。

_version：表示一个版本，当Add元素或者Remove元素等时候，会自增。我们在foreach list过程中如果list改变了，那么会抛出异常（好像是集合已修改，不能枚举），就是根据它来判断的。

List<T>的构造函数

static List()
        {
            List<T>._emptyArray = new T[0];//每个T 都有一个对应的new T[0]
        }

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public List()
        {
            this._items = List<T>._emptyArray;//比如：对于所有的new List<int>()对象都共享同一份空数组。设计的目的可能为了性能优化。
        }

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public List(int capacity)
        {
            if (capacity < 0)
            {
                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
            }
            this._items = new T[capacity];//可以看出capacity就是内部数组的Length啦。
        }

        public List(IEnumerable<T> collection)
        {
            if (collection == null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
            }
            ICollection<T> is2 = collection as ICollection<T>;
            if (is2 != null)
            {
                int count = is2.Count;
                this._items = new T[count];
                is2.CopyTo(this._items, 0);//这样的初始化直接数组对拷，性能很高。
                this._size = count;
            }
            else
            {
                this._size = 0;//您是否有疑问，为什么这个下面代码中没有该修改过该值呢？它可表示list元素的个数啊，其实秘密在Add方法中。
                this._items = new T[4];//看到伐，直接写死的4，不知道是反编译还是源代码就这样写的，大神您怎么看？
                using (IEnumerator<T> enumerator = collection.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        this.Add(enumerator.Current);
                    }
                }
            }
        }

 

List<T>的常用方法成员

public void Add(T item)
        {
            if (this._size == this._items.Length)
            {
                this.EnsureCapacity(this._size + 1);
            }
            this._items[this._size++] = item;
            this._version++;
        }

 当元素个数和内部数组（_items）Length相等时，那么就要确保_items的Length必须有this._size+1。顺便提一下，可以看到Add方法不是thread safe的，其实内部有一个

 internal static IList<T> Synchronized(List<T> list)
        {
            return new SynchronizedList<T>(list);
        }

 

private void EnsureCapacity(int min)
        {
            if (this._items.Length < min)
            {
                int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);//容量是以2倍于原容量来增长的，我们知道数组是定长的，一旦分配后，长度不可改变，那么List如何扩容的呢？看下面
                if (num < min)
                {
                    num = min;
                }
                this.Capacity = num;
            }
        }
public int Capacity//对于扩容这样一个高消耗操作，用一个属性的set来设置，是否合适，为啥不写成一个方法SetCapacity(int c)呢？大神您怎么看？
        {
            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return this._items.Length;
            }
            set
            {
                if (value < this._size)
                {
                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);
                }
                if (value != this._items.Length)
                {
                    if (value > 0)
                    {
                        T[] destinationArray = new T[value];//看到木，重写分配一个新数组，将原数组中元素copy到新数组中。所以如果一开始就知道或者可以预估List的容量，可以new List（x）
                        if (this._size > 0)　　　　　　　　　　//来避免以后List的扩容，可能造成的性能影响（如GC回收原数组，copy大量元素等）。
                        {
                            Array.Copy(this._items, 0, destinationArray, 0, this._size);
                        }
                        this._items = destinationArray;
                    }
                    else
                    {
                        this._items = List<T>._emptyArray;
                    }
                }
            }
        }

 

下面来看看AddRange

  public void AddRange(IEnumerable<T> collection)
        {
            this.InsertRange(this._size, collection);
        }
public void InsertRange(int index, IEnumerable<T> collection)
        {
            if (collection == null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
            }
            if (index > this._size)
            {
                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
            }
            ICollection<T> is2 = collection as ICollection<T>;
            if (is2 != null)//如果实现了ICollection<T>，特殊对待，直接使用高性能的Array.Copy（是一个extern外部实现）
            {
                int count = is2.Count;
                if (count > 0)
                {
                    this.EnsureCapacity(this._size + count);
                    if (index < this._size)
                    {
                        Array.Copy(this._items, index, this._items, index + count, this._size - index);
                    }
                    if (this == is2)//特殊对待
                    {
                        Array.Copy(this._items, 0, this._items, index, index);
                        Array.Copy(this._items, (int) (index + count), this._items, (int) (index * 2), (int) (this._size - index));
                    }
                    else
                    {
                        T[] array = new T[count];//创建新数组
                        is2.CopyTo(array, 0);//将待添加元素先copy到新数组
                        array.CopyTo(this._items, index);//把新数组copy到List后面。wait等等，各位看官有木有发现，为什么要创建临时数组啊，直接is2.CopyTo(this.items,。。)，且看下面测试结果。
                    }
                    this._size += count;
                }
            }
            else
            {
                using (IEnumerator<T> enumerator = collection.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        this.Insert(index++, enumerator.Current);
                    }
                }
            }
            this._version++;
        }

 

 public T[] ToArray()
        {
            T[] destinationArray = new T[this._size];//创建新数组
            Array.Copy(this._items, 0, destinationArray, 0, this._size);
            return destinationArray;
        }
//在内部的 public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator中，下面两个方法为什么不合并成一个啊？还有这个struct为什么没有这样Enumerator<T>呢？您看懂没，反正我看了半天懂了:)
public bool MoveNext()
            {
                List<T> list = this.list;
                if ((this.version == list._version) && (this.index < list._size))
                {
                    this.current = list._items[this.index];
                    this.index++;
                    return true;
                }
                return this.MoveNextRare();
            }

            private bool MoveNextRare()
            {
                if (this.version != this.list._version)
                {
                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
                }
                this.index = this.list._size + 1;
                this.current = default(T);
                return false;
            }

 

public bool Contains(T item)
        {
            if (item == null)
            {
                for (int j = 0; j < this._size; j++)
                {
                    if (this._items[j] == null)
                    {
                        return true;
                    }
                }
                return false;
            }
            EqualityComparer<T> comparer = EqualityComparer<T>.Default;
            for (int i = 0; i < this._size; i++)//顺序查找啊，在序言中那个问题，如果使用Dictionary查找，查找复杂度近似O(1)啊，以后在说这个问题。
            {
                if (comparer.Equals(this._items[i], item))//依赖于T是否实现接口
                {
                    return true;
                }
            }
            return false;
        }

其他方法不解释了，有兴趣自己去看看啦。

其中，AddRange方法是否真的比Add方法性能高

测试代码：

static List<int> GetData(int length)
        {
            List<int> result = new List<int>(length);//潜移默化的影响，哈哈哈
            for (int i = 0; i < length; i++)
            {
                result.Add(i);
            }
            return result;
        }
        static void Main()
        {
            int itemLength = 10;
            List<int> itemList = GetData(itemLength);

            int iteration = 1000000;
            List<int> firstList = new List<int>(itemLength*iteration);
            List<int> secondList = new List<int>(itemLength * iteration);

            CodeTimer.Initialize();
            CodeTimer.Time("AddRange方法测试", iteration, () => {
                firstList.AddRange(itemList);
            });
            CodeTimer.Time("Add方法测试", iteration, () =>
            {
                for (int i = 0; i < itemList.Count; i++)
                {
                    secondList.Add(itemList[i]);
                }
            });
            Console.ReadKey();
        }

通过故意执行多次AddRange，让其内部不断的创建临时数组，可以看到下面的结果，消耗的时间既然比Add多，而且Gen 0 有33的垃圾回收。AddRange中创建临时数组，到底算不算疏忽，写FCL的工程师应该技术水平不容质疑吧，难道故意的，大神您怎么看？:)

测试结果如下：

类型字典（Type Dictionary）

还是来看下Contains中，比较两个元素是否相等，其中：

public abstract class EqualityComparer<T> : IEqualityComparer, IEqualityComparer<T>
    {
        private static EqualityComparer<T> defaultComparer;

        protected EqualityComparer()
        {
        }

        [SecuritySafeCritical]
        private static EqualityComparer<T> CreateComparer()
        {
            RuntimeType c = (RuntimeType) typeof(T);
            if (c == typeof(byte))
            {
                return (EqualityComparer<T>) new ByteEqualityComparer();
            }
            if (typeof(IEquatable<T>).IsAssignableFrom(c))
            {
                return (EqualityComparer<T>) RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType) typeof(GenericEqualityComparer<int>), c);
            }
            if (c.IsGenericType && (c.GetGenericTypeDefinition() == typeof(Nullable<>)))
            {
                RuntimeType type2 = (RuntimeType) c.GetGenericArguments()[0];
                if (typeof(IEquatable<>).MakeGenericType(new Type[] { type2 }).IsAssignableFrom(type2))
                {
                    return (EqualityComparer<T>) RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType) typeof(NullableEqualityComparer<int>), type2);
                }
            }
            if (c.IsEnum && (Enum.GetUnderlyingType(c) == typeof(int)))
            {
                return (EqualityComparer<T>) RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType) typeof(EnumEqualityComparer<int>), c);
            }
            return new ObjectEqualityComparer<T>();
        }

        public abstract bool Equals(T x, T y);
        public abstract int GetHashCode(T obj);
        internal virtual int IndexOf(T[] array, T value, int startIndex, int count)
        {
            int num = startIndex + count;
            for (int i = startIndex; i < num; i++)
            {
                if (this.Equals(array[i], value))
                {
                    return i;
                }
            }
            return -1;
        }

        internal virtual int LastIndexOf(T[] array, T value, int startIndex, int count)
        {
            int num = (startIndex - count) + 1;
            for (int i = startIndex; i >= num; i--)
            {
                if (this.Equals(array[i], value))
                {
                    return i;
                }
            }
            return -1;
        }

        bool IEqualityComparer.Equals(object x, object y)
        {
            if (x == y)
            {
                return true;
            }
            if ((x != null) && (y != null))
            {
                if ((x is T) && (y is T))
                {
                    return this.Equals((T) x, (T) y);
                }
                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
            }
            return false;
        }

        int IEqualityComparer.GetHashCode(object obj)
        {
            if (obj != null)
            {
                if (obj is T)
                {
                    return this.GetHashCode((T) obj);
                }
                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
            }
            return 0;
        }

        public static EqualityComparer<T> Default
        {
            [SecuritySafeCritical, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                EqualityComparer<T> defaultComparer = EqualityComparer<T>.defaultComparer;
                if (defaultComparer == null)
                {
                    defaultComparer = EqualityComparer<T>.CreateComparer();
                    EqualityComparer<T>.defaultComparer = defaultComparer;
                }
                return defaultComparer;
            }
        }
    }

 泛型类中，静态字段private static EqualityComparer<T> defaultComparer;会为每个T类型都缓存一份该数据，是这样去初始化的：

public static EqualityComparer<T> Default
        {
            [SecuritySafeCritical, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                EqualityComparer<T> defaultComparer = EqualityComparer<T>.defaultComparer;
                if (defaultComparer == null)
                {
                    defaultComparer = EqualityComparer<T>.CreateComparer();
                    EqualityComparer<T>.defaultComparer = defaultComparer;
                }
                return defaultComparer;
            }
        }

 其实发现很多FCL中代码都是这样的模式，可学习使用在平时工作项目中。Type Dictionary真是一劳永逸的哦，貌似某大神说是必备技能啊，有兴趣的可以看我之前写的几篇文章。

总结

　　通过阅读分析FCL源码，可以更清楚知道实现细节，更高效的使用，可学习MS大神们的代码和设计，命名规范等等，总之，好处多多，其他好处等着你来补充:)。当我们看懂代码意思后，能否思考为什么要这样设计，这样设计的好处是什么，这将是更高一层次的武功了。

　　如有不正之处，还请斧正，谢谢大家。期待着大家的讨论~~