Обновить все объекты в коллекции с помощью LINQ

Для этого нет встроенного метода расширения. Хотя определить одно довольно просто. Внизу поста находится метод, который я определил под названием 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++;
    }
}

Нет, LINQ не поддерживает способ массового обновления. Единственный способ короче - использовать метод расширения ForEach - Почему в IEnumerable нет метода расширения ForEach?

Я предполагаю, что вы хотите изменить значения внутри запроса, чтобы вы могли написать для него функцию

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; }
}

Но не сомневайтесь, если это вы имеете в виду.

Мои 2 копейки: -

 collection.Count(v => (v.PropertyToUpdate = newValue) == null);

Я действительно нашел метод расширения, который будет делать то, что я хочу, красиво

public static IEnumerable<T> ForEach<T>(
    this IEnumerable<T> source,
    Action<T> act)
{
    foreach (T element in source) act(element);
    return source;
}

Хотя вы можете использовать метод расширения ForEach, если вы хотите использовать только фреймворк, вы можете сделать

collection.Select(c => {c.PropertyToSet = value; return c;}).ToList();

ToList необходим для немедленной оценки выбора из-за ленивая оценка.

Вы можете использовать LINQ для преобразования вашей коллекции в массив, а затем вызвать Array.ForEach ():

Array.ForEach(MyCollection.ToArray(), item=>item.DoSomeStuff());

Очевидно, это не будет работать с коллекциями структур или встроенными типами, такими как целые числа или строки.

Вы можете использовать Magiq, платформу пакетных операций для LINQ.

Вот метод расширения, который я использую ...

    /// <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;
    }

Я пробовал несколько вариантов этого и продолжаю возвращаться к решению этого парня.

http://www.hookedonlinq.com/UpdateOperator.ashx

Опять же, это чужое решение. Но я скомпилировал код в небольшую библиотеку и довольно регулярно использую ее.

Я собираюсь вставить сюда его код на случай, если его сайт (блог) перестанет существовать в какой-то момент в будущем. (Нет ничего хуже, чем увидеть сообщение "Вот точный ответ, который вам нужен", Click и Dead 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; } );

collection.ToList().ForEach(c => c.PropertyToSet = value);

Я делаю это

Collection.All(c => { c.needsChange = value; return true; });

Использовать:

ListOfStuff.Where(w => w.Thing == value).ToList().ForEach(f => f.OtherThing = vauleForNewOtherThing);

Я не уверен, злоупотребляет ли это LINQ или нет, но это сработало для меня, когда я хотел обновить определенные элементы в списке для определенного условия.

Я написал несколько методов расширения, чтобы помочь мне в этом.

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");
            }
        }

    }
}

Хотя вы специально просили решение LINQ, и этот вопрос довольно старый, я публикую решение, не связанное с LINQ. Это потому, что LINQ (= интегрированный язык запрос) предназначен для использования для запросов к коллекциям. Все LINQ-методы не изменяют базовую коллекцию, они просто возвращаться создают новую (или, точнее, итератор для новой коллекции). Таким образом, что бы вы ни делали, например с Select не влияет на базовую коллекцию, вы просто получаете новую.

Конечно, вы мог делаете это с ForEach (кстати, это не LINQ, а расширение на List<T>). Но этот буквально все равно использует foreach, но с лямбда-выражением. Помимо этого каждый метод LINQ выполняет внутреннюю итерацию вашей коллекции, например. используя foreach или for, однако он просто скрывает это от клиента. Я не считаю это более удобным для чтения и сопровождения (подумайте о редактировании кода при отладке метода, содержащего лямбда-выражения).

При этом не следует использовать элементы LINQ to модифицировать в вашей коллекции. Лучший способ - это решение, которое вы уже указали в своем вопросе. С помощью классического цикла вы можете легко перебирать свою коллекцию и обновлять ее элементы. На самом деле, все решения, основанные на List.ForEach, ничем не отличаются, но с моей точки зрения их гораздо труднее читать.

Поэтому вам не следует использовать LINQ в тех случаях, когда вы хотите Обновить элементов вашей коллекции.

Предположим, у нас есть данные, как показано ниже,

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;