有没有办法使用 LINQ 执行以下操作?
foreach (var c in collection)
{
c.PropertyToSet = value;
}
为了澄清,我想遍历集合中的每个对象,然后更新每个对象的属性。
我的用例是我对博客文章有一堆评论,我想遍历博客文章的每条评论,并将博客文章的日期时间设置为 +10 小时。我可以在 SQL 中做到这一点,但我想将它保留在业务层中。
虽然您可以使用 ForEach
扩展方法,但如果您只想使用框架,您可以这样做
collection.Select(c => {c.PropertyToSet = value; return c;}).ToList();
由于延迟评估,需要 ToList
来立即评估选择。
collection.ToList().ForEach(c => c.PropertyToSet = value);
collection.ToList().ForEach(c => { c.Property1ToSet = value1; c.Property2ToSet = value2; });
collection.ToList().ForEach(c => { collection[collection.IndexOf(c)] = new <struct type>() { <propertyToSet> = value, <propertyToRetain> = c.Property2Retain }; });
我正在这样做
Collection.All(c => { c.needsChange = value; return true; });
All()
扩展方法的意图,当其他人阅读代码时可能会造成混淆。
List<>
这样的集合,ForEach()
方法是完成此任务的一种更简单的方法。前 ForEach(c => { c.needsChange = value; })
我实际上找到了一个扩展方法,可以很好地做我想做的事
public static IEnumerable<T> ForEach<T>(
this IEnumerable<T> source,
Action<T> act)
{
foreach (T element in source) act(element);
return source;
}
foreach
循环(无论出于何种原因),这是唯一有用的方法。
foreach
因为代码本身包含 foreach
循环
foreach(Foo foo in foos){ statement involving foo; }
扩展方法:foos.ForEach((Foo foo)=>{ statement involving foo; });
利用:
ListOfStuff.Where(w => w.Thing == value).ToList().ForEach(f => f.OtherThing = vauleForNewOtherThing);
我不确定这是否过度使用 LINQ,但是当我想针对特定条件更新列表中的特定项目时,它对我有用。
尽管您特别要求提供 LINQ 解决方案并且这个问题已经很老了,但我发布了一个非 LINQ 解决方案。这是因为 LINQ(= 语言集成 query)旨在用于对集合进行查询。所有 LINQ 方法都不会修改底层集合,它们只是返回一个新集合(或更准确地说是一个新集合的迭代器)。因此,无论您使用 Select
做什么都不会影响基础集合,您只需获得一个新集合。
当然,您可以使用 ForEach
(顺便说一下,它不是 LINQ,而是 List<T>
上的扩展)来实现。但是这个 字面意思 无论如何都使用 foreach
,但带有 lambda 表达式。除了这个 every LINQ 方法在内部迭代您的集合,例如使用 foreach
或 for
,但它只是对客户端隐藏它。我不认为这更具可读性和可维护性(考虑在调试包含 lambda 表达式的方法时编辑代码)。
话虽如此,这不应该使用 LINQ 来修改您的收藏中的项目。更好的方法是您在问题中已经提供的解决方案。使用经典循环,您可以轻松地迭代您的集合并更新其项目。事实上,所有这些依赖于 List.ForEach
的解决方案都没有什么不同,但从我的角度来看,要阅读起来要困难得多。
因此,在您想要更新集合元素的情况下,您不应该使用 LINQ。
for
循环。我觉得创建完成简单任务的不太冗长的方式是语法糖,而不是替代标准编码。
没有内置的扩展方法可以做到这一点。虽然定义一个是相当直接的。在帖子的底部是我定义的一个名为 Iterate 的方法。可以这样使用
collection.Iterate(c => { c.PropertyToSet = value;} );
迭代源
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++;
}
}
我已经尝试了一些变体,并且我继续回到这个人的解决方案。
http://www.hookedonlinq.com/UpdateOperator.ashx
同样,这是其他人的解决方案。但是我已经将代码编译成一个小库,并且经常使用它。
我将在此处粘贴他的代码,以防他的网站(博客)在未来某个时候不复存在。 (没有什么比看到一个帖子说“这是您需要的确切答案”、点击和死 URL 更糟糕的了。)
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++;
}
return count;
}
}
int count = drawingObjects
.Where(d => d.IsSelected && d.Color == Colors.Blue)
.Update(e => { e.Color = Color.Red; e.Selected = false; } );
Action<TSource>
而不是创建额外的委托。不过,在撰写本文时,这可能还不可用。
where T: struct
)在编译时捕获它可能会更好。
不,LINQ 不支持大规模更新的方式。唯一更短的方法是使用 ForEach
扩展方法 - Why there is no ForEach extension method on IEnumerable?
我的2便士:-
collection.Count(v => (v.PropertyToUpdate = newValue) == null);
您可以使用 LINQ 将您的集合转换为数组,然后调用 Array.ForEach():
Array.ForEach(MyCollection.ToArray(), item=>item.DoSomeStuff());
显然,这不适用于结构集合或内置类型(如整数或字符串)。
我写了一些扩展方法来帮助我解决这个问题。
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;
}
}
}
我这样使用它:
List<int> exampleList = new List<int>()
{
1, 2 , 3
};
//2 , 3 , 4
var updated1 = exampleList.Change(x => x + 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
供参考参数检查:
/// <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) ||
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");
}
}
}
}
这是我使用的扩展方法...
/// <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++;
}
return count;
}
List<T>.ForEach
的作用,但仅适用于所有 IEnumerable
。
有些人认为这是一个评论,但对我来说是一个答案,因为做错事的正确方法是不去做。所以,这个问题的答案就在问题本身。
不要使用 LINQ 修改数据。使用循环。
我假设您想更改查询中的值,以便您可以为它编写一个函数
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; }
}
但是,如果这就是您的意思,请不要确定。
引用 Adi Lester 的回答 (https://stackoverflow.com/a/5755487/8917485)
我很喜欢这个答案,但是这个答案有一个错误。它只是更改新创建的列表中的值。它必须改为两行才能读取真正的更改列表。
var aList = collection.ToList();
aList.ForEach(c => c.PropertyToSet = value);
collection.ToList().ForEach(c => c.PropertyToSet = value)
永久更改 collection
中的所有项目,它们碰巧以哪种方式被枚举并不重要。
假设我们有如下数据,
var items = new List<string>({"123", "456", "789"});
// Like 123 value get updated to 123ABC ..
如果我们想修改列表并将列表的现有值替换为修改后的值,则首先创建一个新的空列表,然后通过对每个列表项调用修改方法来循环数据列表,
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;
ObservableCollection
的说法,那么就地更改项目而不是创建一个新列表可能会很有用。