14

如果我没记错的话，ToList() 方法会在提供的集合的每个元素上进行迭代，并将它们添加到 List 的新实例中并返回此实例。假设一个示例

//using linq
list = Students.Where(s => s.Name == "ABC").ToList();

//traditional way
foreach (var student in Students)
{
  if (student.Name == "ABC")
    list.Add(student);
}

我认为传统方式更快，因为它只循环一次，其中 Linq 上面的 Where 方法迭代两次，然后是 ToList() 方法。

我正在从事的项目现在广泛使用列表，我看到如果我将列表变量作为IEnumerable并删除 .ToList () 并将其进一步用作 IEnumerable。

这些东西对性能有影响吗？

4

4 回答 4

12

这些东西对性能有影响吗？

这取决于您的代码。大多数情况下，使用 LINQ 确实会对性能造成很小的影响。在某些情况下，这种影响对您来说可能很重要，但只有在您知道 LINQ 对您来说太慢时才应该避免使用 LINQ（即，如果分析您的代码表明 LINQ 是您的代码缓慢的原因）。

但是你是对的，ToList()过于频繁地使用会导致严重的性能问题。你应该ToList()只在必要时打电话。请注意，在某些情况下，添加ToList()可以大大提高性能（例如，每次迭代时从数据库加载集合时）。

关于迭代次数：这取决于“迭代两次”的确切含义。如果您计算在某个集合上调用的次数MoveNext()，那么是的，使用Where()这种方式会导致迭代两次。操作顺序是这样的（为了简化，我将假设所有项目都符合条件）：

  1. Where()被调用，暂时没有迭代，Where()返回一个特殊的枚举。
  2. ToList()被调用，调用MoveNext()从Where().
  3. Where()现在调用MoveNext()原始集合并获取值。
  4. Where()调用你的谓词，它返回true.
  5. MoveNext()ToList()从返回中调用，ToList()获取值并将其添加到列表中。
  6. …</li>

这意味着如果原始集合中的所有n 个MoveNext()项目都符合条件，则将被调用 2 n次、n次 fromWhere()和n次 from ToList()。

于 2013-02-22T15:31:04.863 回答
5 
var list = Students.Where(s=>s.Name == "ABC");

这只会创建一个查询并且在使用查询之前不会循环元素。通过调用 ToList() 将首先执行查询，因此只循环一次您的元素。

List<Student> studentList = new List<Student>();
var list = Students.Where(s=>s.Name == "ABC");
foreach(Student s in list)
{
    studentList.add(s);
}

这个例子也只会迭代一次。因为它只用过一次。请记住，该列表将在每次调用时迭代所有学生。不仅仅是那些名字是 ABC 的学生。因为它是一个查询。

对于后面的讨论，我做了一个测试示例。也许它不是 IEnumable 的最佳实现，但它做了它应该做的事情。

首先我们有我们的清单

public class TestList<T> : IEnumerable<T>
{
    private TestEnumerator<T> _Enumerator;

    public TestList()
    {
        _Enumerator = new TestEnumerator<T>();
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _Enumerator;
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }

    internal void Add(T p)
    {
        _Enumerator.Add(p);
    }
}

由于我们想计算调用 MoveNext 的次数，我们必须实现我们的自定义枚举器 aswel。在 MoveNext 中观察，我们的程序中有一个静态计数器。

公共类 TestEnumerator : IEnumerator { public Item FirstItem = null; 公共项目 CurrentItem = null;

    public TestEnumerator()
    {
    }

    public T Current
    {
        get { return CurrentItem.Value; }
    }

    public void Dispose()
    {

    }

    object System.Collections.IEnumerator.Current
    {
        get { throw new NotImplementedException(); }
    }

    public bool MoveNext()
    {
        Program.Counter++;
        if (CurrentItem == null)
        {
            CurrentItem = FirstItem;
            return true;
        }
        if (CurrentItem != null && CurrentItem.NextItem != null)
        {
            CurrentItem = CurrentItem.NextItem;
            return true;
        }
        return false;
    }

    public void Reset()
    {
        CurrentItem = null;
    }

    internal void Add(T p)
    {
        if (FirstItem == null)
        {
            FirstItem = new Item<T>(p);
            return;
        }
        Item<T> lastItem = FirstItem;
        while (lastItem.NextItem != null)
        {
            lastItem = lastItem.NextItem;
        }
        lastItem.NextItem = new Item<T>(p);
    }
}

然后我们有一个自定义项目，它只是包装我们的价值

public class Item<T>
{
    public Item(T item)
    {
        Value = item;
    }

    public T Value;

    public Item<T> NextItem;
}

为了使用实际代码，我们创建了一个包含 3 个条目的“列表”。

    public static int Counter = 0;
    static void Main(string[] args)
    {
        TestList<int> list = new TestList<int>();
        list.Add(1);
        list.Add(2);
        list.Add(3);

        var v = list.Where(c => c == 2).ToList(); //will use movenext 4 times
        var v = list.Where(c => true).ToList();   //will also use movenext 4 times


        List<int> tmpList = new List<int>(); //And the loop in OP question
        foreach(var i in list)
        {
            tmpList.Add(i);
        }                                    //Also 4 times.
    }

和结论？它如何影响性能？在这种情况下，MoveNext 被调用 n+1 次。不管我们有多少物品。而且 WhereClause 也无所谓，他仍然会运行 MoveNext 4 次。因为我们总是在我们的初始列表上运行我们的查询。我们将受到的唯一性能影响是实际的 LINQ 框架及其调用。实际制作的循环将是相同的。

在有人问为什么它是 N+1 次而不是 N 次之前。这是因为他最后一次没有元素时返回 false。使其成为元素的数量+列表的结尾。

于 2013-02-22T15:24:44.700 回答
2

要完全回答这个问题，这取决于实现。如果您正在谈论 LINQ to SQL/EF，那么在这种情况下，当调用 .ToList 时将只有一次迭代，它在内部调用 .GetEnumerator。然后将查询表达式解析为 TSQL 并传递给数据库。然后将生成的行迭代（一次）并添加到列表中。

在 LINQ to Objects 的情况下，也只有一次数据传递。在 where 子句中使用 yield return 在内部设置了一个状态机，用于跟踪进程在迭代中的位置。Where 不进行完整迭代，创建一个临时列表，然后将这些结果传递给查询的其余部分。它只是确定一个项目是否符合标准，并且只传递那些匹配的项目。

于 2013-02-22T16:42:02.453 回答
1

首先，你为什么还要问我？自己量一下看看。

也就是说，Where,Select和OrderBy其他 LINQIEnumerable扩展方法，一般来说，实现得尽可能惰性（该yield关键字经常使用）。这意味着除非他们必须这样做，否则他们不会处理数据。从你的例子：

var list = Students.Where(s => s.Name == "ABC");

不会执行任何东西。即使Students是 1000 万个对象的列表，它也会立即返回。在某个地方实际请求结果之前，根本不会调用谓词，这实际上就是ToList()这样做的：它说“是的，结果 - 所有这些 - 都是立即需要的”。

然而，调用 LINQ 方法有一些初始开销，因此传统方法通常会更快，但 LINQ 方法的可组合性和易用性，恕我直言，足以弥补这一点。

如果您想了解这些方法是如何实现的，可以从Microsoft Reference Sources中获得参考。

于 2013-02-22T15:35:24.043 回答