实质：List是C#提供的最常见的可伸缩 数组 组件，是通过数组这种数据结构来实现的，而并非链表。使用时无须手动分配内存空间大小，全由List内部类来进行自动扩容分配。

构造部分源码：

public class List<T> : IList<T>, System.Collection.IList, iReadOnlyList<T> {
    private const int _defaultCapacity = 4;    //默认容器大小
    
    private T[] _items;    //核心存储数据结构（一个数组）
    private int _size;    //容器大小
    private int _version;    //容器版本
    private Object _syncRoot;

    static readonly T[] _emptyArray = new T[0];    //创建容器时，创建了一个为空的数组

    //不指定大小的默认构造函数，赋值了一个空的容器
    public List() {
        _items = _emptyArray;
    }

    //指定容器大小的构造函数
    public List(int capacity) {
        //如果指定容器值小于0，抛错。
        if (capacity < 0) ThrowHelper.ThrowArgumentOutOfRangeException(
        ExceptionArgument.capacity,
        ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
        Contract.EndContractBlock();

        if (capacity == 0)
            _items = _emptyArray;
        else
            _items = new T[capacity];  
    }
    ......
}

Add方法源码：

public void Add(T item) {
    //检测容量，并扩容
    if (_size == _items.Length) EnsureCapacity(_size + 1);
    _items[_size++] = _items; //将元素添加到数组末尾
    _version++; //版本更新
}

private void EnsureCapacity(int min) {
    if (_items.Length < min) {
        //如果超出了容量，则直接将容量扩充至2倍大小，如果容量本身为0，则扩充为默认大小。
        int newCapacity = _items.Length == 0 ? _defaultCapacity : _items.Length * 2;
        //如果容量扩充超过了最大数组容量，则将容量变为最大数组容量
        if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
        //如果扩充的容量还是小于当前元素大小，则扩充至当前元素大小
        if (newCapacity < min) newCapacity = min;
        Capacity = newCapacity; //容量赋值
    }
}

Remove方法源码：

//删除给定索引处的元素，列表的大小减1
public bool Remove(T item) {
    int index = IndexOf(item); //查找元素索引
    if (index >= 0) {
        RemoveAt(index); //有索引则删除指定索引
        return true;
    }
    return false;
}

//返回此列表范围内给定值首次出现的索引
//实质是从头到尾向前遍历搜索
//使用Object.Equals方法将列表中的元素与给定值进行比较
public int IndexOf(T item) {
    Contract.Ensure(Contract.Result<int>() >= -1);
    Contract.Ensure(Contract.Result<int>() < count);
    return Array.IndexOf(_items, item, 0, _size); //实质是使用数组内置的IndexOf方法进行查询
}

//删除指定索引处的元素。列表大小减1
public void RemoveAt(int index) {
    //索引范围检测
    if ((uint)index >= (uint)_size) {
        ThrowHelper.ThorwArgumentOutOfRangeException();
    }
    Contract.EndContractBlock();
    _size--; //列表大小减1
    if (index < _size) {
        //实质是使用数组内置的Copy方法进行数组覆盖
        Array.Copy(_items, index + 1, _items, index, _size - index);  //重点：(_size已经提前减1，所以能直接用于计算长度)
    }
    _items[_size] = default[T];
    _version++;
}

Insert方法源码：

private void Insert(int index, T item) {
    if ((uint)index > (uint)_size) {
        //索引检测
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index,
            ExceptionResource.ArgumentOutOfRange_ListInsert);
    }
    Contract.EndContractBlock();
    if (_size == items.Length) EnsureCapacity(_size + 1); //容量检测
    if (index < _size) {
        //通过复制操作，覆盖数组
        Array.Copy(_items, index, _items, index + 1, _size - index);
    }
    _items[index] = item; //指定位置赋值
    _size++; //容量+1
    _version++;
}

Contains方法：遍历数组（线性），通过item.Equals方法来比较查找元素是否在数组中。
ToArray方法：利用数组Array.Copy方法创建并复制了一个新的数组返回。
Find方法：遍历数组（线性），通过match方法来比较查找元素，并返回。
ForEach方法：创建新的枚举器实例，通过枚举器来进行遍历操作。（在实际项目中尽量避免使用ForEach函数，因为每次使用ForEach函数都会创建一个新的枚举器实例，最终通过GC单元垃圾回收，大量使用会造成性能问题。）
Sort方法：使用快速排序算法进行排序。

总结：List的实质是对数据用数组进行保存，并拥有一系列维护方法的特殊类，代码是线程不安全的。在效率方面比数组还要差，只是兼容性比较强罢了。