blocks|key|4031502|text|运行LINQ查询不会存储结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4031503|相反，它将在您每次枚举该查询时重新执行该查询。|4031504|调用Save()之后，查询将为空，因为没有一个条目满足where子句。|offset|length|style|CODE|4031505|将其更改为|4031506|var+unsaved+=+group.Where(g+=>+!g.SomeProp).ToList();|code-block|syntax|javascript|4031507|调用ToList()会将结果存储在List<T>中；这可以避免重新执行查询。|4031508|entityMap^0|0|0|2|6|R|5|0|0|0|2|8|H|7|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@$F|X|G|Y|H|I]|$F|Z|G|10|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|13|8|@$F|14|G|15|H|I]|$F|16|G|17|H|I]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

Running a LINQ query does not store the results. 
Instead, it will re-execute the query each time you enumerate it.

After calling <code>Save()</code>, the query will be empty, since none of the items meet the <code>where</code> clause. 

Change it to 

<pre><code>var unsaved = group.Where(g =&gt; !g.SomeProp).ToList();
</code></pre>

Calling <code>ToList()</code> will store the results in a <code>List&lt;T&gt;</code>; this avoids re-executing the query.

blocks|key|4031533|text|你的问题出在LINQ的Lazy+Evalution上。在第一个示例中，LINQ查询实际上运行了两次。第一个用于枚举调用Save()方法，第二个用于获取Any()。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4031534|使用LINQ时的一般规则是，在每个查询之后放入ToList()。|4031535|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/ericwhite/archive/2006/10/04/lazy-evaluation-_2800_and-in-contrast_2c00_-eager-evaluation_2900_.aspx^0|B|E|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Your problem lies in <a href="http://blogs.msdn.com/b/ericwhite/archive/2006/10/04/lazy-evaluation-_2800_and-in-contrast_2c00_-eager-evaluation_2900_.aspx" rel="nofollow">Lazy Evalution</a> of LINQ. In first example, the LINQ query is actualy run TWICE. First for enumerating for calling your Save() method, and second to get Any().

As general rule while working with LINQ, put ToList() after each and every query.

blocks|key|4031573|text|您的问题是由于deferred+execution而发生的。在您的第一个示例中，groupWithFalse并不表示SomeProp为false的对象列表，它引用了一个可以计算出该列表的查询。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4031574|如果你想让你的列表在整个函数中保持不变，只需在LINQ查询的末尾添加.ToList()，如下所示：|4031575|IEnumerable<SomeClass>+groupWithFalse+=(from+SomeClass+gr+in+group
++++++++++++++++++++++++++++++++++++++++where+gr.SomeProp+==+false
++++++++++++++++++++++++++++++++++++++++select+gr).ToList();
//++++++++++++++++++++++++++++++++++++++++++++++++%5E%5E%5E%5E%5E%5E%5E%5E%5E+|code-block|syntax|javascript|4031576|这将导致查询立即执行，并将其结果返回到一个List<SomeClass>中，如果您修改其中的对象，它的内容将不会更改。|4031577|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-execution.aspx^0|14|E|1M|8|7|I|0|0|Y|9|0|0|L|F|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Your problem is occurring because of <a href="http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-execution.aspx" rel="nofollow">deferred execution</a>. In your first example, <code>groupWithFalse</code> doesn't represent a list of objects where <code>SomeProp</code> is false, it refers to a query that can evaluate to said list.

If you want your list to stay put during your entire function, simply add <code>.ToList()</code> on the end of your LINQ query like so:

<pre><code>IEnumerable&lt;SomeClass&gt; groupWithFalse =(from SomeClass gr in group
 where gr.SomeProp == false
 select gr).ToList();
// ^^^^^^^^^ 
</code></pre>

This will cause the query to execute immediately and return its results into a <code>List&lt;SomeClass&gt;</code> whose contents won't change if you modify the objects within it.

blocks|key|1535294|text|好的，在第一个实现中，您正在定义一个迭代器groupWithFalse，该迭代器遍历group中将SomeProp设置为false的元素。您已经对groupWithFalse进行了迭代，并将所有这些元素的SomeProp设置为true。现在，当您再次迭代时(对Any的调用将产生第二次迭代)，每个元素都将SomeProp设置为true，因为您只是将其设置为true，因此Any当然会返回false+(迭代现在会生成空集合)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1535295|详述一下，基本上当你说|1535296|IEnumerable<SomeClass>+groupWithFalse+=(from+SomeClass+gr+in+group
++++++++++++++++++++++++++++++++++++++++where+gr.SomeProp==+false
++++++++++++++++++++++++++++++++++++++++select+gr);|code-block|syntax|javascript|1535297|您正在定义一个对象(groupWithFalse)，该对象捕获这样的逻辑：“给我一个group中SomeProp设置为false的元素序列”。显式地，这个对象实际上不是SomeProp设置为false的那些元素的集合或序列。第一次迭代此对象(foreach)时，此规则将生成SomeProp为false的元素(如果group中有元素的话)。但是当您再次迭代(Any)时，此规则将不会生成任何元素，因为您已经修改了此规则从中提取其元素的集合group。|1535298|在第二次迭代中，您将检查名为groupWithFalse的List<SomeClass>是否是空集合，这是因为您在紧接在它前面的foreach循环中向它添加了元素。|1535299|下面是我如何编写你的代码：|1535300|public+static+void+SomeMethod+(List<SomeClass>+group)+{
++++IEnumerable<SomeClass>+groupWithFalse+=(from+SomeClass+gr+in+group
++++++++++++++++++++++++++++++++++++++++++++where+gr.SomeProp==+false
++++++++++++++++++++++++++++++++++++++++++++select+gr);
++++if(groupWithFalse.Any())+{
++++++++foreach+(SomeClass+grFalse+in+groupWithFalse)+{
++++++++++++grFalse.Save();
++++++++}

++++++++//+do+some+stuff
++++}
}|1535301|现在的代码类似于“获取SomeProp为false的group的元素。如果有Any，就Save它们，然后做一些事情。”|1535302|entityMap^0|L|E|16|5|1D|8|1O|5|21|E|2U|8|35|4|3M|3|48|8|4J|4|4Y|4|55|3|5D|5|0|0|0|A|E|16|5|1C|8|2C|8|3D|7|3T|8|42|5|4D|5|4Z|3|63|5|0|E|E|T|F|1S|7|0|0|0|B|8|K|5|Q|5|12|3|17|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1P|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]|$9|28|A|29|B|C]|$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2J|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|2K|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|2L|8|@$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]]|X|$]]

Okay, in the first implementation what is happening is that you are defining an iterator <code>groupWithFalse</code> that iterates over the elements of <code>group</code> that have <code>SomeProp</code> set to <code>false</code>. You've iterated over <code>groupWithFalse</code> and set <code>SomeProp</code> to <code>true</code> for all of those elements and now when you iterate again (the call to <code>Any</code> produces a second iteration), every element has <code>SomeProp</code> set to <code>true</code> since you just set it to be so and so of course <code>Any</code> returns <code>false</code> (the iteration produces the empty collection now).

To elaborate a little bit, basically when you say

<pre><code>IEnumerable&lt;SomeClass&gt; groupWithFalse =(from SomeClass gr in group
 where gr.SomeProp== false
 select gr);
</code></pre>

you are defining an object (<code>groupWithFalse</code>) that captures the logic "give me a sequence of the elements in <code>group</code> that have <code>SomeProp</code> set to false." Explicitly, this object is not actually a collection or sequence of those elements for which <code>SomeProp</code> is set to false. The first time that you iterate over this object (<code>foreach</code>), this rule will produce elements for which <code>SomeProp</code> is <code>false</code> (if there are any in <code>group</code>). But when you iterate a second time (<code>Any</code>), this rule will not produce any elements because you've modified the collection <code>group</code> from which this rule draws its elements from.

In the second iteration you are checking if the <code>List&lt;SomeClass&gt;</code> named <code>groupWithFalse</code> is the empty collection which it is not because you've added elements to it in the <code>foreach</code> loop that immediately precedes it.

Here's how I would write your code:

<pre><code>public static void SomeMethod (List&lt;SomeClass&gt; group) {
 IEnumerable&lt;SomeClass&gt; groupWithFalse =(from SomeClass gr in group
 where gr.SomeProp== false
 select gr);
 if(groupWithFalse.Any()) {
 foreach (SomeClass grFalse in groupWithFalse) {
 grFalse.Save();
 }

 // do some stuff
 }
}
</code></pre>

Now the code reads like "Get the elements of <code>group</code> for which <code>SomeProp</code> is <code>false</code>. If there are <code>Any</code>, <code>Save</code> them and then do some stuff."

blocks|key|367385|text|在第一个示例中，您正在使用IEnumerable。把它想象成一个查询，而不是一个对象列表。因此，您将使用上面的查询遍历整个集合"group“，该查询表示”仅迭代SomeProp等于false的元素“。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|367386|然后在foreach语句中修改"group“列表中对象的状态。|367387|然后，您在查询中应用了额外的谓词，即“在"group”列表中是否有任何元素的某些属性等于false?“很明显，你会得到一个回答：“不，没有一个”。|367388|在第二个示例中，您只获得新的元素集合，而不是查询。因此，您可以遍历它，更改状态，然后询问“是否有任何元素？”得到一个“是”的回答。有与以前相同的元素，但更改了SomeProp属性值。|367389|entityMap^0|0|4|0|0|0|0|4|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|M|$]]

In the first example you are using IEnumerable. Think about it like a query, not a list of objects. So then you are iterating through entire collection "group" using above query that says "iterate only elements that have SomeProp equal to false". 

Then in your foreach statement you modify the state of the object in "group" list.

And then you are applying additional predicate on you query that states "Are there any elements in "group" list that have some prop equal to false?" And you obviously recieve an answer "no there are none of them".

In the second example you just getting new collection of elements, NOT a query. So then you iterate over it, chage state and then ask "Are there any elements?" And recive an "yes" answer. There are the same elements as before but with changed SomeProp property value.

I have the following BL method

<pre><code>public static void SomeMethod (List&lt;SomeClass&gt; group)
{
 IEnumerable&lt;SomeClass&gt; groupWithFalse =(from SomeClass gr in group
 where gr.SomeProp== false
 select gr);
 foreach (SomeClass grFalse in groupWithFalse)
 {
 grFalse.Save();
 }

 if (groupWithFalse.Any())
 {
 // do some stuff
 }
}
</code></pre>

The mock implementation for dl saving (which cannot be changed as it used in a lot of unit tests) is:

<pre><code>public void Save()
{
 group.SomeProp = true;
}
</code></pre>

If I try to unit test the last statement of the flow e.g if <code>(groupWithFalse.Any())</code> the statement fails, as apparently there are no more elements with that property set to false.
If I change the code in business logic to :

<pre><code>public static void SomeMethod (List&lt;SomeClass&gt; group)
{
 List&lt;SomeClass&gt; groupWithFalse = new List&lt;SomeClass&gt;();
 foreach (var g in group)
 {
 if (g.SomeProp == false)
 groupWithFalse.Add(g);
 }

 foreach (SomeClass grFalse in groupWithFalse)
 {
 grFalse.Save();
 }

 if (groupWithFalse.Any())
 {
 // do some stuff
 }
}
</code></pre>

the conditional statement <code>if (groupWithFalse.Any())</code> does not fail in unit tests. Why does this happen? Thanks

Why does this happen IEnumerable versus List

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有下面的BL方法public static void SomeMethod (List<SomeClass> group){ IEnumerable<SomeClass> groupWithFalse =(from SomeClass gr in group ...

问为什么会发生IEnumerable而不是List
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么会发生IEnumerable而不是ListEN