blocks|key|158109|text|虽然您可以使用ForEach扩展方法，但如果您只想使用框架，您可以这样做|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|158110|collection.Select(c+=>+{c.PropertyToSet+=+value;+return+c;}).ToList();|code-block|syntax|javascript|158111|由于延迟求值，因此需要ToList来立即计算select。|158112|entityMap^0|7|7|0|0|B|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

While you can use a <code>ForEach</code> extension method, if you want to use just the framework you can do

<pre><code>collection.Select(c =&gt; {c.PropertyToSet = value; return c;}).ToList();
</code></pre>

The <code>ToList</code> is needed in order to evaluate the select immediately due to lazy evaluation.

blocks|key|4221328|text|collection.ToList().ForEach(c+=>+c.PropertyToSet+=+value);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4221329|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>collection.ToList().ForEach(c =&gt; c.PropertyToSet = value);
</code></pre>

blocks|key|158258|text|我正在做这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|158259|Collection.All(c+=>+{+c.needsChange+=+value;+return+true;+});|code-block|syntax|javascript|158260|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I am doing this

<pre><code>Collection.All(c =&gt; { c.needsChange = value; return true; });
</code></pre>

blocks|key|158087|text|实际上，我找到了一个扩展方法，它可以很好地完成我想要做的事情|type|unstyled|depth|inlineStyleRanges|entityRanges|data|158088|public+static+IEnumerable<T>+ForEach<T>(
++++this+IEnumerable<T>+source,
++++Action<T>+act)
{
++++foreach+(T+element+in+source)+act(element);
++++return+source;
}|code-block|syntax|javascript|158089|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I actually found an extension method that will do what I want nicely
<pre><code>public static IEnumerable&lt;T&gt; ForEach&lt;T&gt;(
 this IEnumerable&lt;T&gt; source,
 Action&lt;T&gt; act)
{
 foreach (T element in source) act(element);
 return source;
}
</code></pre>

blocks|key|158297|text|使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|158298|ListOfStuff.Where(w+=>+w.Thing+==+value).ToList().ForEach(f+=>+f.OtherThing+=+vauleForNewOtherThing);|code-block|syntax|javascript|158299|我不确定这是否过度使用LINQ，但当我想要针对特定条件更新列表中的特定项时，它对我很有效。|158300|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Use:

<pre><code>ListOfStuff.Where(w =&gt; w.Thing == value).ToList().ForEach(f =&gt; f.OtherThing = vauleForNewOtherThing);
</code></pre>

I am not sure if this is overusing LINQ or not, but it has worked for me when wanting to update a specific items in the list for a specific condition.

blocks|key|4221452|text|虽然你特别要求一个LINQ解决方案，而且这个问题已经很陈旧了，但我还是发布了一个非LINQ解决方案。这是因为LINQ+(=+language+integrated+query)旨在用于集合上的查询。所有的LINQ方法都不会修改底层的集合，它们只是返回一个新的集合(或者更准确地说，是一个新集合的迭代器)。因此，无论您对Select做什么，都不会影响底层集合，您只需获得一个新的集合。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|4221453|当然，您也可以使用ForEach+(顺便说一句，它不是LINQ，而是List<T>上的一个扩展)。但这实际上使用了foreach，但使用了一个lambda-expression。除此之外，每个LINQ方法都会在内部迭代您的集合，例如使用foreach或for，但它只是对客户端隐藏它。我不认为这更具可读性和可维护性(考虑一下在调试包含lambda表达式的方法时编辑代码)。|4221454|话虽如此，但不应该使用LINQ来修改集合中的项。一个更好的方法是你已经在你的问题中提供的解决方案。使用经典循环，您可以轻松地迭代集合并更新其项。事实上，所有这些依赖于List.ForEach的解决方案都没有什么不同，但从我的角度来看，阅读起来要难得多。|4221455|因此，在需要更新集合元素的情况下，不应该使用LINQ。|4221456|entityMap^0|2A|5|4F|6|0|9|7|Y|7|1L|7|3A|7|3I|3|0|2B|C|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|T|8|@$9|U|A|V|B|D]|$9|W|A|X|B|D]|$9|Y|A|Z|B|D]|$9|10|A|11|B|D]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|I|3|J|5|6|7|14|8|@$9|15|A|16|B|D]]|E|@]|F|$]]|$1|K|3|L|5|6|7|17|8|@]|E|@]|F|$]]|$1|M|3|-4|5|6|7|18|8|@]|E|@]|F|$]]]|N|$]]

Although you specifically asked for a LINQ solution and this question is quite old I post a non-LINQ-solution. This is because LINQ (= 
language integrated query) is meant to be used for queries on collections. All LINQ-methods don’t modify the underlying collection, they just return a new one (or more precise an iterator to a new collection). Thus whatever you do e.g. with a <code>Select</code> doesn’t effect the underlying collection, you simply get a new one.

Of course you could do it with a <code>ForEach</code> (which isn't LINQ, by the way, but an extension on <code>List&lt;T&gt;</code>). But this literally uses <code>foreach</code> anyway, but with a lambda-expression. Apart from this every LINQ method internally iterates your collection e.g. by using <code>foreach</code> or <code>for</code>, however it simply hides it from the client. I don’t consider this any more readable nor maintainable (think of edit your code while debugging a method containing lambda-expressions).

Having said this shouldn't use LINQ to modify items in your collection. A better way is the solution you already provided in your question. With a classic loop you can easily iterate your collection and update its items. In fact all those solutions relying on <code>List.ForEach</code> are nothing different, but far harder to read from my perspective.

So you shouldn't use LINQ in those cases where you want to update the elements of your collection.

blocks|key|940994|text|没有内置的扩展方法可以做到这一点。尽管定义一个是相当简单的。在post的底部是我定义的一个名为Iterate的方法。它可以像这样使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|940995|collection.Iterate(c+=>+{+c.PropertyToSet+=+value;}+);|code-block|syntax|javascript|940996|迭代源|940997|public+static+void+Iterate<T>(this+IEnumerable<T>+enumerable,+Action<T>+callback)
{
++++if+(enumerable+==+null)
++++{
++++++++throw+new+ArgumentNullException("enumerable");
++++}

++++IterateHelper(enumerable,+(x,+i)+=>+callback(x));
}

public+static+void+Iterate<T>(this+IEnumerable<T>+enumerable,+Action<T,int>+callback)
{
++++if+(enumerable+==+null)
++++{
++++++++throw+new+ArgumentNullException("enumerable");
++++}

++++IterateHelper(enumerable,+callback);
}

private+static+void+IterateHelper<T>(this+IEnumerable<T>+enumerable,+Action<T,int>+callback)
{
++++int+count+=+0;
++++foreach+(var+cur+in+enumerable)
++++{
++++++++callback(cur,+count);
++++++++count%2B%2B;
++++}
}|940998|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There is no built-in extension method to do this. Although defining one is fairly straight forward. At the bottom of the post is a method I defined called Iterate. It can be used like so

<pre><code>collection.Iterate(c =&gt; { c.PropertyToSet = value;} );
</code></pre>

Iterate Source

<pre><code>public static void Iterate&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, Action&lt;T&gt; callback)
{
 if (enumerable == null)
 {
 throw new ArgumentNullException("enumerable");
 }

 IterateHelper(enumerable, (x, i) =&gt; callback(x));
}

public static void Iterate&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, Action&lt;T,int&gt; callback)
{
 if (enumerable == null)
 {
 throw new ArgumentNullException("enumerable");
 }

 IterateHelper(enumerable, callback);
}

private static void IterateHelper&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, Action&lt;T,int&gt; callback)
{
 int count = 0;
 foreach (var cur in enumerable)
 {
 callback(cur, count);
 count++;
 }
}
</code></pre>

blocks|key|158242|text|我已经尝试了几种不同的解决方案，并且我一直在使用这个人的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|158243|http://www.hookedonlinq.com/UpdateOperator.ashx|offset|length|158244|再说一次，这是别人的解决方案。但是我已经将代码编译成一个小的库，并且经常使用它。|158245|我将在这里粘贴他的代码，以防他的网站(博客)在未来的某个时候不复存在。(没有什么比看到这样的帖子更糟糕的了：“这是你需要的确切答案”、“点击”和“死网址”。)|158246|++++public+static+class+UpdateExtensions+{

++++public+delegate+void+Func<TArg0>(TArg0+element);

++++///+<summary>
++++///+Executes+an+Update+statement+block+on+all+elements+in+an+IEnumerable<T>+sequence.
++++///+</summary>
++++///+<typeparam+name="TSource">The+source+element+type.</typeparam>
++++///+<param+name="source">The+source+sequence.</param>
++++///+<param+name="update">The+update+statement+to+execute+for+each+element.</param>
++++///+<returns>The+numer+of+records+affected.</returns>
++++public+static+int+Update<TSource>(this+IEnumerable<TSource>+source,+Func<TSource>+update)
++++{
++++++++if+(source+==+null)+throw+new+ArgumentNullException("source");
++++++++if+(update+==+null)+throw+new+ArgumentNullException("update");
++++++++if+(typeof(TSource).IsValueType)
++++++++++++throw+new+NotSupportedException("value+type+elements+are+not+supported+by+update.");

++++++++int+count+=+0;
++++++++foreach+(TSource+element+in+source)
++++++++{
++++++++++++update(element);
++++++++++++count%2B%2B;
++++++++}
++++++++return+count;
++++}
}



int+count+=+drawingObjects
++++++++.Where(d+=>+d.IsSelected+&&+d.Color+==+Colors.Blue)
++++++++.Update(e+=>+{+e.Color+=+Color.Red;+e.Selected+=+false;+}+);|code-block|syntax|javascript|158247|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|12|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|C]]]]

I've tried a few variations on this, and I keep going back to this guy's solution.

<a href="http://www.hookedonlinq.com/UpdateOperator.ashx" rel="noreferrer">http://www.hookedonlinq.com/UpdateOperator.ashx</a>

Again, this is somebody else's solution. But I've compiled the code into a small library, and use it fairly regularly.

I'm going to paste his code here, for the off chance that his site(blog) ceases to exist at some point in the future. (There's nothing worse than seeing a post that says "Here is the exact answer you need", Click, and Dead URL.)

<pre><code> public static class UpdateExtensions {

 public delegate void Func&lt;TArg0&gt;(TArg0 element);

 /// &lt;summary&gt;
 /// Executes an Update statement block on all elements in an IEnumerable&lt;T&gt; sequence.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="TSource"&gt;The source element type.&lt;/typeparam&gt;
 /// &lt;param name="source"&gt;The source sequence.&lt;/param&gt;
 /// &lt;param name="update"&gt;The update statement to execute for each element.&lt;/param&gt;
 /// &lt;returns&gt;The numer of records affected.&lt;/returns&gt;
 public static int Update&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, Func&lt;TSource&gt; update)
 {
 if (source == null) throw new ArgumentNullException("source");
 if (update == null) throw new ArgumentNullException("update");
 if (typeof(TSource).IsValueType)
 throw new NotSupportedException("value type elements are not supported by update.");

 int count = 0;
 foreach (TSource element in source)
 {
 update(element);
 count++;
 }
 return count;
 }
}



int count = drawingObjects
 .Where(d =&gt; d.IsSelected &amp;&amp; d.Color == Colors.Blue)
 .Update(e =&gt; { e.Color = Color.Red; e.Selected = false; } );
</code></pre>

blocks|key|941007|text|不，LINQ不支持批量更新的方式。唯一更短的方法是使用ForEach扩展方法--+Why+there+is+no+ForEach+extension+method+on+IEnumerable?|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|941008|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/101265/why-is-there-not-a-foreach-extension-method-on-the-ienumerable-interface#101303^0|R|7|15|1K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

No, LINQ doesn't support a manner of mass updating. The only shorter way would be to use a <code>ForEach</code> extension method - <a href="https://stackoverflow.com/questions/101265/why-is-there-not-a-foreach-extension-method-on-the-ienumerable-interface#101303">Why there is no ForEach extension method on IEnumerable?</a>

blocks|key|941029|text|我的两便士：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|941030|+collection.Count(v+=>+(v.PropertyToUpdate+=+newValue)+==+null);|code-block|syntax|javascript|941031|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My 2 pennies:-

<pre><code> collection.Count(v =&gt; (v.PropertyToUpdate = newValue) == null);
</code></pre>

blocks|key|3374889|text|您可以使用LINQ将集合转换为数组，然后调用Array.ForEach()：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3374890|Array.ForEach(MyCollection.ToArray(),+item=>item.DoSomeStuff());|code-block|syntax|javascript|3374891|显然，这不适用于结构或内置类型的集合，如整数或字符串。|3374892|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use LINQ to convert your collection to an array and then invoke Array.ForEach():

<pre><code>Array.ForEach(MyCollection.ToArray(), item=&gt;item.DoSomeStuff());
</code></pre>

Obviously this will not work with collections of structs or inbuilt types like integers or strings.

blocks|key|4221406|text|我写了一些扩展方法来帮助我解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4221407|namespace+System.Linq
{
++++///+<summary>
++++///+Class+to+hold+extension+methods+to+Linq.
++++///+</summary>
++++public+static+class+LinqExtensions
++++{
++++++++///+<summary>
++++++++///+Changes+all+elements+of+IEnumerable+by+the+change+function
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="change">The+way+you+want+to+change+the+stuff</param>
++++++++///+<returns>An+IEnumerable+with+all+changes+applied</returns>
++++++++public+static+IEnumerable<T>+Change<T>(this+IEnumerable<T>+enumerable,+Func<T,+T>+change++)
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(change,+"change");

++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++yield+return+change(item);
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Changes+all+elements+of+IEnumerable+by+the+change+function,+that+fullfill+the+where+function
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="change">The+way+you+want+to+change+the+stuff</param>
++++++++///+<param+name="where">The+function+to+check+where+changes+should+be+made</param>
++++++++///+<returns>
++++++++///+An+IEnumerable+with+all+changes+applied
++++++++///+</returns>
++++++++public+static+IEnumerable<T>+ChangeWhere<T>(this+IEnumerable<T>+enumerable,+
++++++++++++++++++++++++++++++++++++++++++++++++++++Func<T,+T>+change,
++++++++++++++++++++++++++++++++++++++++++++++++++++Func<T,+bool>+@where)
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(change,+"change");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(@where,+"where");

++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++if+(@where(item))
++++++++++++++++{
++++++++++++++++++++yield+return+change(item);
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++yield+return+item;
++++++++++++++++}
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Changes+all+elements+of+IEnumerable+by+the+change+function+that+do+not+fullfill+the+except+function
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="change">The+way+you+want+to+change+the+stuff</param>
++++++++///+<param+name="where">The+function+to+check+where+changes+should+not+be+made</param>
++++++++///+<returns>
++++++++///+An+IEnumerable+with+all+changes+applied
++++++++///+</returns>
++++++++public+static+IEnumerable<T>+ChangeExcept<T>(this+IEnumerable<T>+enumerable,
+++++++++++++++++++++++++++++++++++++++++++++++++++++Func<T,+T>+change,
+++++++++++++++++++++++++++++++++++++++++++++++++++++Func<T,+bool>+@where)
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(change,+"change");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(@where,+"where");

++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++if+(!@where(item))
++++++++++++++++{
++++++++++++++++++++yield+return+change(item);
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++yield+return+item;
++++++++++++++++}
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Update+all+elements+of+IEnumerable+by+the+update+function+(only+works+with+reference+types)
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="update">The+way+you+want+to+change+the+stuff</param>
++++++++///+<returns>
++++++++///+The+same+enumerable+you+passed+in
++++++++///+</returns>
++++++++public+static+IEnumerable<T>+Update<T>(this+IEnumerable<T>+enumerable,
+++++++++++++++++++++++++++++++++++++++++++++++Action<T>+update)+where+T+:+class
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(update,+"update");
++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++update(item);
++++++++++++}
++++++++++++return+enumerable;
++++++++}

++++++++///+<summary>
++++++++///+Update+all+elements+of+IEnumerable+by+the+update+function+(only+works+with+reference+types)
++++++++///+where+the+where+function+returns+true
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="update">The+way+you+want+to+change+the+stuff</param>
++++++++///+<param+name="where">The+function+to+check+where+updates+should+be+made</param>
++++++++///+<returns>
++++++++///+The+same+enumerable+you+passed+in
++++++++///+</returns>
++++++++public+static+IEnumerable<T>+UpdateWhere<T>(this+IEnumerable<T>+enumerable,
+++++++++++++++++++++++++++++++++++++++++++++++Action<T>+update,+Func<T,+bool>+where)+where+T+:+class
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(update,+"update");
++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++if+(where(item))
++++++++++++++++{
++++++++++++++++++++update(item);
++++++++++++++++}
++++++++++++}
++++++++++++return+enumerable;
++++++++}

++++++++///+<summary>
++++++++///+Update+all+elements+of+IEnumerable+by+the+update+function+(only+works+with+reference+types)
++++++++///+Except+the+elements+from+the+where+function
++++++++///+</summary>
++++++++///+<param+name="enumerable">The+enumerable+where+you+want+to+change+stuff</param>
++++++++///+<param+name="update">The+way+you+want+to+change+the+stuff</param>
++++++++///+<param+name="where">The+function+to+check+where+changes+should+not+be+made</param>
++++++++///+<returns>
++++++++///+The+same+enumerable+you+passed+in
++++++++///+</returns>
++++++++public+static+IEnumerable<T>+UpdateExcept<T>(this+IEnumerable<T>+enumerable,
+++++++++++++++++++++++++++++++++++++++++++++++Action<T>+update,+Func<T,+bool>+where)+where+T+:+class
++++++++{
++++++++++++ArgumentCheck.IsNullorWhiteSpace(enumerable,+"enumerable");
++++++++++++ArgumentCheck.IsNullorWhiteSpace(update,+"update");

++++++++++++foreach+(var+item+in+enumerable)
++++++++++++{
++++++++++++++++if+(!where(item))
++++++++++++++++{
++++++++++++++++++++update(item);
++++++++++++++++}
++++++++++++}
++++++++++++return+enumerable;
++++++++}
++++}
}|code-block|syntax|javascript|4221408|我是这样使用它的：|4221409|++++++++List<int>+exampleList+=+new+List<int>()
++++++++++++{
++++++++++++++++1,+2+,+3
++++++++++++};

++++++++//2+,+3+,+4
++++++++var+updated1+=+exampleList.Change(x+=>+x+%2B+1);

++++++++//10,+2,+3
++++++++var+updated2+=+exampleList
++++++++++++.ChangeWhere(+++changeItem+=>+changeItem+*+10,++++++++++//+change+you+want+to+make
++++++++++++++++++++++++++++conditionItem+=>+conditionItem+<+2);++++//+where+you+want+to+make+the+change

++++++++//1,+0,+0
++++++++var+updated3+=+exampleList
++++++++++++.ChangeExcept(changeItem+=>+0,++++++++++++++++++++++++++//Change+elements+to+0
++++++++++++++++++++++++++conditionItem+=>+conditionItem+==+1);+++++//everywhere+but+where+element+is+1|4221410|要引用参数，请检查：|4221411|///+<summary>
///+Class+for+doing+argument+checks
///+</summary>
public+static+class+ArgumentCheck
{


++++///+<summary>
++++///+Checks+if+a+value+is+string+or+any+other+object+if+it+is+string
++++///+it+checks+for+nullorwhitespace+otherwhise+it+checks+for+null+only
++++///+</summary>
++++///+<typeparam+name="T">Type+of+the+item+you+want+to+check</typeparam>
++++///+<param+name="item">The+item+you+want+to+check</param>
++++///+<param+name="nameOfTheArgument">Name+of+the+argument</param>
++++public+static+void+IsNullorWhiteSpace<T>(T+item,+string+nameOfTheArgument+=+"")
++++{

++++++++Type+type+=+typeof(T);
++++++++if+(type+==+typeof(string)+%7C%7C
++++++++++++type+==+typeof(String))
++++++++{
++++++++++++if+(string.IsNullOrWhiteSpace(item+as+string))
++++++++++++{
++++++++++++++++throw+new+ArgumentException(nameOfTheArgument+%2B+"+is+null+or+Whitespace");
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++if+(item+==+null)
++++++++++++{
++++++++++++++++throw+new+ArgumentException(nameOfTheArgument+%2B+"+is+null");
++++++++++++}
++++++++}

++++}
}|4221412|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I wrote some extension methods to help me out with that. 

<pre><code>namespace System.Linq
{
 /// &lt;summary&gt;
 /// Class to hold extension methods to Linq.
 /// &lt;/summary&gt;
 public static class LinqExtensions
 {
 /// &lt;summary&gt;
 /// Changes all elements of IEnumerable by the change function
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="change"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;returns&gt;An IEnumerable with all changes applied&lt;/returns&gt;
 public static IEnumerable&lt;T&gt; Change&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, Func&lt;T, T&gt; change )
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(change, "change");

 foreach (var item in enumerable)
 {
 yield return change(item);
 }
 }

 /// &lt;summary&gt;
 /// Changes all elements of IEnumerable by the change function, that fullfill the where function
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="change"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;param name="where"&gt;The function to check where changes should be made&lt;/param&gt;
 /// &lt;returns&gt;
 /// An IEnumerable with all changes applied
 /// &lt;/returns&gt;
 public static IEnumerable&lt;T&gt; ChangeWhere&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable, 
 Func&lt;T, T&gt; change,
 Func&lt;T, bool&gt; @where)
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(change, "change");
 ArgumentCheck.IsNullorWhiteSpace(@where, "where");

 foreach (var item in enumerable)
 {
 if (@where(item))
 {
 yield return change(item);
 }
 else
 {
 yield return item;
 }
 }
 }

 /// &lt;summary&gt;
 /// Changes all elements of IEnumerable by the change function that do not fullfill the except function
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="change"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;param name="where"&gt;The function to check where changes should not be made&lt;/param&gt;
 /// &lt;returns&gt;
 /// An IEnumerable with all changes applied
 /// &lt;/returns&gt;
 public static IEnumerable&lt;T&gt; ChangeExcept&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable,
 Func&lt;T, T&gt; change,
 Func&lt;T, bool&gt; @where)
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(change, "change");
 ArgumentCheck.IsNullorWhiteSpace(@where, "where");

 foreach (var item in enumerable)
 {
 if (!@where(item))
 {
 yield return change(item);
 }
 else
 {
 yield return item;
 }
 }
 }

 /// &lt;summary&gt;
 /// Update all elements of IEnumerable by the update function (only works with reference types)
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="update"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;returns&gt;
 /// The same enumerable you passed in
 /// &lt;/returns&gt;
 public static IEnumerable&lt;T&gt; Update&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable,
 Action&lt;T&gt; update) where T : class
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(update, "update");
 foreach (var item in enumerable)
 {
 update(item);
 }
 return enumerable;
 }

 /// &lt;summary&gt;
 /// Update all elements of IEnumerable by the update function (only works with reference types)
 /// where the where function returns true
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="update"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;param name="where"&gt;The function to check where updates should be made&lt;/param&gt;
 /// &lt;returns&gt;
 /// The same enumerable you passed in
 /// &lt;/returns&gt;
 public static IEnumerable&lt;T&gt; UpdateWhere&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable,
 Action&lt;T&gt; update, Func&lt;T, bool&gt; where) where T : class
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(update, "update");
 foreach (var item in enumerable)
 {
 if (where(item))
 {
 update(item);
 }
 }
 return enumerable;
 }

 /// &lt;summary&gt;
 /// Update all elements of IEnumerable by the update function (only works with reference types)
 /// Except the elements from the where function
 /// &lt;/summary&gt;
 /// &lt;param name="enumerable"&gt;The enumerable where you want to change stuff&lt;/param&gt;
 /// &lt;param name="update"&gt;The way you want to change the stuff&lt;/param&gt;
 /// &lt;param name="where"&gt;The function to check where changes should not be made&lt;/param&gt;
 /// &lt;returns&gt;
 /// The same enumerable you passed in
 /// &lt;/returns&gt;
 public static IEnumerable&lt;T&gt; UpdateExcept&lt;T&gt;(this IEnumerable&lt;T&gt; enumerable,
 Action&lt;T&gt; update, Func&lt;T, bool&gt; where) where T : class
 {
 ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
 ArgumentCheck.IsNullorWhiteSpace(update, "update");

 foreach (var item in enumerable)
 {
 if (!where(item))
 {
 update(item);
 }
 }
 return enumerable;
 }
 }
}
</code></pre>

I am using it like this:

<pre><code> List&lt;int&gt; exampleList = new List&lt;int&gt;()
 {
 1, 2 , 3
 };

 //2 , 3 , 4
 var updated1 = exampleList.Change(x =&gt; x + 1);

 //10, 2, 3
 var updated2 = exampleList
 .ChangeWhere( changeItem =&gt; changeItem * 10, // change you want to make
 conditionItem =&gt; conditionItem &lt; 2); // where you want to make the change

 //1, 0, 0
 var updated3 = exampleList
 .ChangeExcept(changeItem =&gt; 0, //Change elements to 0
 conditionItem =&gt; conditionItem == 1); //everywhere but where element is 1
</code></pre>

For reference the argument check:

<pre><code>/// &lt;summary&gt;
/// Class for doing argument checks
/// &lt;/summary&gt;
public static class ArgumentCheck
{


 /// &lt;summary&gt;
 /// Checks if a value is string or any other object if it is string
 /// it checks for nullorwhitespace otherwhise it checks for null only
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Type of the item you want to check&lt;/typeparam&gt;
 /// &lt;param name="item"&gt;The item you want to check&lt;/param&gt;
 /// &lt;param name="nameOfTheArgument"&gt;Name of the argument&lt;/param&gt;
 public static void IsNullorWhiteSpace&lt;T&gt;(T item, string nameOfTheArgument = "")
 {

 Type type = typeof(T);
 if (type == typeof(string) ||
 type == typeof(String))
 {
 if (string.IsNullOrWhiteSpace(item as string))
 {
 throw new ArgumentException(nameOfTheArgument + " is null or Whitespace");
 }
 }
 else
 {
 if (item == null)
 {
 throw new ArgumentException(nameOfTheArgument + " is null");
 }
 }

 }
}
</code></pre>

blocks|key|158173|text|您可以使用Magiq，一个用于LINQ的批处理操作框架。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|158174|entityMap|0|LINK|mutability|MUTABLE|url|http://magiq.codeplex.com/^0|5|5|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can use <a href="http://magiq.codeplex.com" rel="nofollow noreferrer">Magiq</a>, a batch operation framework for LINQ.

blocks|key|3374935|text|下面是我使用的扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3374936|++++///+<summary>
++++///+Executes+an+Update+statement+block+on+all+elements+in+an++IEnumerable+of+T
++++///+sequence.
++++///+</summary>
++++///+<typeparam+name="TSource">The+source+element+type.</typeparam>
++++///+<param+name="source">The+source+sequence.</param>
++++///+<param+name="action">The+action+method+to+execute+for+each+element.</param>
++++///+<returns>The+number+of+records+affected.</returns>
++++public+static+int+Update<TSource>(this+IEnumerable<TSource>+source,+Func<TSource>+action)
++++{
++++++++if+(source+==+null)+throw+new+ArgumentNullException("source");
++++++++if+(action+==+null)+throw+new+ArgumentNullException("action");
++++++++if+(typeof+(TSource).IsValueType)
++++++++++++throw+new+NotSupportedException("value+type+elements+are+not+supported+by+update.");

++++++++var+count+=+0;
++++++++foreach+(var+element+in+source)
++++++++{
++++++++++++action(element);
++++++++++++count%2B%2B;
++++++++}
++++++++return+count;
++++}|code-block|syntax|javascript|3374937|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the extension method I use...

<pre><code> /// &lt;summary&gt;
 /// Executes an Update statement block on all elements in an IEnumerable of T
 /// sequence.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="TSource"&gt;The source element type.&lt;/typeparam&gt;
 /// &lt;param name="source"&gt;The source sequence.&lt;/param&gt;
 /// &lt;param name="action"&gt;The action method to execute for each element.&lt;/param&gt;
 /// &lt;returns&gt;The number of records affected.&lt;/returns&gt;
 public static int Update&lt;TSource&gt;(this IEnumerable&lt;TSource&gt; source, Func&lt;TSource&gt; action)
 {
 if (source == null) throw new ArgumentNullException("source");
 if (action == null) throw new ArgumentNullException("action");
 if (typeof (TSource).IsValueType)
 throw new NotSupportedException("value type elements are not supported by update.");

 var count = 0;
 foreach (var element in source)
 {
 action(element);
 count++;
 }
 return count;
 }
</code></pre>

blocks|key|4221553|text|有些人认为这是一个评论，但对我来说，这是一个答案，因为做错事情的正确方法是不做它。所以，这个问题的答案就在问题本身。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4221554|4221555|不使用LINQ修改数据。使用循环。|blockquote|4221556|4221557|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|J|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|K|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|H|$]]

Some people consider this is a comment, but for me is an answer, because the right way to do something wrong is not do it. So, the answer for this question is in the question itself.
<blockquote>
DO NOT USE LINQ to modify data. Use a loop.
</blockquote>

blocks|key|3374802|text|我假设您想要更改查询中的值，以便可以为其编写函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3374803|void+DoStuff()
{
++++Func<string,+Foo,+bool>+test+=+(y,+x)+=>+{+x.Bar+=+y;+return+true;+};
++++List<Foo>+mylist+=+new+List<Foo>();
++++var+v+=+from+x+in+mylist
++++++++++++where+test("value",+x)
++++++++++++select+x;
}

class+Foo
{
++++string+Bar+{+get;+set;+}
}|code-block|syntax|javascript|3374804|但不是舒尔，如果你是这个意思的话。|3374805|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I assume you want to change values inside a query so you could write a function for it

<pre><code>void DoStuff()
{
 Func&lt;string, Foo, bool&gt; test = (y, x) =&gt; { x.Bar = y; return true; };
 List&lt;Foo&gt; mylist = new List&lt;Foo&gt;();
 var v = from x in mylist
 where test("value", x)
 select x;
}

class Foo
{
 string Bar { get; set; }
}
</code></pre>

But not shure if this is what you mean.

blocks|key|941216|text|假设我们有如下数据，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|941217|var+items+=+new+List<string>({"123",+"456",+"789"});
//+Like+123+value+get+updated+to+123ABC+..|code-block|syntax|javascript|941218|如果我们想要修改列表并将列表的现有值替换为修改后的值，则首先创建一个新的空列表，然后通过对每个列表项调用修改方法来遍历数据列表。|941219|var+modifiedItemsList+=+new+List<string>();

items.ForEach(i+=>+{
++var+modifiedValue+=+ModifyingMethod(i);
++modifiedItemsList.Add(items.AsEnumerable().Where(w+=>+w+==+i).Select(x+=>+modifiedValue).ToList().FirstOrDefault()?.ToString())+
});
//+assign+back+the+modified+list
items+=+modifiedItemsList;|941220|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Suppose we have data like below,

<pre><code>var items = new List&lt;string&gt;({"123", "456", "789"});
// Like 123 value get updated to 123ABC ..
</code></pre>

and if we want to modify the list and replace the existing values of the list to modified values, then first create a new empty list, then loop through data list by invoking modifying method on each list item,

<pre><code>var modifiedItemsList = new List&lt;string&gt;();

items.ForEach(i =&gt; {
 var modifiedValue = ModifyingMethod(i);
 modifiedItemsList.Add(items.AsEnumerable().Where(w =&gt; w == i).Select(x =&gt; modifiedValue).ToList().FirstOrDefault()?.ToString()) 
});
// assign back the modified list
items = modifiedItemsList;
</code></pre>

Is there a way to do the following using LINQ?

<pre><code>foreach (var c in collection)
{
 c.PropertyToSet = value;
}
</code></pre>

To clarify, I want to iterate through each object in a collection and then update a property on each object.

My use case is I have a bunch of comments on a blog post, and I want to iterate through each comment on a blog post and set the datetime on the blog post to be +10 hours. I could do it in SQL, but I want to keep it in the business layer.

Update all objects in a collection using LINQ

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有没有办法使用LINQ来做以下事情？foreach (var c in collection){    c.PropertyToSet = value;}为了清楚起见，我希望遍历集合中的每个对象，然后更新每个对象的属性。我的用例是，我对博客帖子有一堆评论，我希望迭代博客帖子上的每个评论，并将博客帖子上的日期时间设置为+10小时。我可以在SQL中完成，但我希望将其保留在业务层中。

问使用LINQ更新集合中的所有对象
EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用LINQ更新集合中的所有对象EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用LINQ更新集合中的所有对象
EN