将列表复制到新列表 - 更高效和最佳实践

Question

将列表复制到新列表的适当方法是什么？ 将列表复制到新列表的最有效方法是什么？

通过效率，而不是代码效率，更多的是在幕后框架意义上。

List<String>List2 = List.ToList();

或者：

List<String>List2 = new List<String>();
foreach (string item in List)
{
 List2.Add(item);
}

更新：

更高效的 IL 代码呢？

Answer 1

鉴于List<T> 有一个IEnumerable<T> 构造函数，我更喜欢这种形式：

List<string> newList = new List<string>(otherList);

编辑

正如 Ondrej 在下面的反编译代码中指出的那样，List<T> 的构造函数预先分配了数组的大小并将内容复制过来。这将比创建一个新列表然后迭代另一个列表单独添加项目要快得多，尤其是在您的第二个示例中，您没有指定要预分配多少项目。

Answer 2

ToList 的作用（缩短）：

public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
{
    return new List<TSource>(source);
}

List ctor 的作用（缩短）：

public List(IEnumerable<T> collection)
{
    ICollection<T> collection2 = collection as ICollection<T>;
    int count = collection2.Count;
    this._items = new T[count];
    collection2.CopyTo(this._items, 0);
    this._size = count;
}

所以 ToList() 效率更高 - 它确实首先分配空间，然后一步复制所有项目。

Answer 3

你可以使用List<T> constructor，它需要IEnumerable<T>

List<string> list1 = new List<string>();

// fill list1

List<string> list2 = new List<string>(list1);

Answer 4

在效率方面，第一个会更快。 List<T> 的底层实现是一个 ArrayList，因此当您调用 .Add 时，您可能需要调整底层数组的大小。

另一方面，.ToList 可以确定新 List 的正确初始大小，并避免 foreach 技术遭受的重新分配操作。

考虑到这一点，我推荐.ToList。更少的代码，它会更快。

您可以运行一个简单的程序来验证ToList 确实更快：

void Main()
{
    List<int> items = new List<int>();

    items = Enumerable.Range(0, 1000000).ToList();

    CopyWithToList(items);
    CopyWithForeach(items);

}

public void CopyWithToList<T>(List<T> list) 
{
    var sw = Stopwatch.StartNew();
    List<T> copy = list.ToList();
    sw.Stop();
    Console.WriteLine("CopyWithToList: {0}", sw.Elapsed);
}

public void CopyWithForeach<T>(List<T> list)
{
    var sw = Stopwatch.StartNew();
    List<T> copy = new List<T>();
    foreach (T item in list) {
        copy.Add(item);
    }
    sw.Stop();

    Console.WriteLine("CopyWithForeach: {0}", sw.Elapsed);
}

Answer 5

测试表明，最佳性能使用 .ToList() 方法（对于具有 21474836 个元素的列表，它在笔记本电脑 Core i5 CPU 上运行大约 48 毫秒）。

其他所有方法都比较慢，使用.Add()的方法最差，同时谈论性能。

这是一些测试代码：

class Program
{
    static void Main()
    {
        var list = new List<int>();

        for (int i = 0; i < int.MaxValue / 100; i++)
        {
            list.Add(i);
        }

        TimeItAccurate(ListCopy_1, list, 10);
        TimeItAccurate(ListCopy_2, list, 10);
        TimeItAccurate(ListCopy_3, list, 10);
        TimeItAccurate(ListCopy_4, list, 10);
        TimeItAccurate(ListCopy_5, list, 10);
    }

    private static List<int> ListCopy_1(List<int> list)
    {
        var newList = list.ToList();

        return newList;
    }

    private static List<int> ListCopy_2(List<int> list)
    {
        var newList = new List<int>(list.Count);

        foreach (var i in list)
        {
            newList.Add(i);
        }

        return newList;
    }

    private static List<int> ListCopy_3(List<int> list)
    {
        var newList = new List<int>(list.ToArray());

        return newList;
    }

    private static List<int> ListCopy_4(List<int> list)
    {
        var newList = new List<int>(list.Count);

        newList.AddRange(list);

        return newList;
    }

    private static List<int> ListCopy_5(List<int> list)
    {
        var newList = new List<int>(list);

        return newList;
    }

    public static void TimeItAccurate<TIn, TResult>(Func<TIn, TResult> func, TIn argument, int iterationsCount)
    {
        #region Pre-heat
        for (int i = 0; i < 10; i++)
        {
            var t = func.Invoke(argument);
        }
        #endregion

        var stopwatch = new Stopwatch();
        var result = default(TResult);

        stopwatch.Start();
        for (int i = 0; i < iterationsCount; i++)
        {
            result = func.Invoke(argument);
        }
        stopwatch.Stop();

        Console.WriteLine("Result:\n{4}(...) == {0}\n\n{1} iterations done in {2} ms.\nAverage time: {3:f5} ms.",
            result,
            iterationsCount,
            stopwatch.ElapsedMilliseconds,
            stopwatch.ElapsedMilliseconds / (double)iterationsCount,
            func.Method.Name);
    }
}

结果：

Result (.ToList()):
ListCopy_1(...) == System.Collections.Generic.List`1[System.Int32]

10 iterations done in 474 ms.
Average time: 47.40000 ms.

Result (for-cycle with .Add()):
ListCopy_2(...) == System.Collections.Generic.List`1[System.Int32]

10 iterations done in 1896 ms.
Average time: 189.60000 ms.

Result (ctor with .ToArray()):
ListCopy_3(...) == System.Collections.Generic.List`1[System.Int32]

10 iterations done in 981 ms.
Average time: 98.10000 ms.

Result (.AddRange()):
ListCopy_4(...) == System.Collections.Generic.List`1[System.Int32]

10 iterations done in 959 ms.
Average time: 95.90000 ms.

Result (new List<int>(list)):
ListCopy_5(...) == System.Collections.Generic.List`1[System.Int32]

10 iterations done in 480 ms.
Average time: 48.00000 ms.

Answer 6

我相信这两个例子是相同的，.ToList() 可能是后者实现的。

最好的表现应该是这样的：

List<String> list2 = new List<String>(list.Count);
foreach(String item in list)
    list2.Add(item);

重要的部分是创建具有足够容量来容纳其内容的 list2。

如果您之后不需要修改任一列表，则您只需要参考副本：

List<String> list2 = list;