Atualizar todos os objetos em uma coleção usando o LINQ

Existe uma maneira de fazer o seguinte usando o LINQ?

foreach (var c in collection)
{
    c.PropertyToSet = value;
}

Para esclarecer, desejo percorrer cada objeto em uma coleção e atualizar uma propriedade em cada objeto.

Meu caso de uso é que tenho vários comentários em uma postagem do blog e quero percorrer cada comentário em uma postagem do blog e definir a data e hora da postagem do blog como +10 horas. Eu poderia fazer isso no SQL, mas quero mantê-lo na camada de negócios.

Embora você possa usar um ForEachmétodo de extensão, se quiser usar apenas a estrutura, poderá

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

A ToListé necessária, a fim de avaliar a escolha de imediato devido à avaliação preguiçosa .

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

Estou fazendo isso

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

Na verdade, eu encontrei um método de extensão que fará o que eu quero bem

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

Usar:

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

Não tenho certeza se isso está usando muito o LINQ ou não, mas funcionou para mim ao querer atualizar itens específicos da lista para uma condição específica.

Não há método de extensão interno para fazer isso. Embora definir um seja bastante direto. Na parte inferior da postagem há um método que eu defini chamado Iterate. Pode ser usado assim

collection.Iterate(c => { c.PropertyToSet = value;} );

Iterar Origem

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

Embora você tenha solicitado especificamente uma solução LINQ e essa pergunta seja bastante antiga, eu posto uma solução não-LINQ. Isso ocorre porque o LINQ (= consulta integrada ao idioma ) deve ser usado para consultas em coleções. Todos os métodos LINQ não modificam a coleção subjacente, apenas retornam uma nova (ou um iterador mais preciso para uma nova coleção). Assim, o que você faz, por exemplo, com a Selectnão afeta a coleção subjacente, você simplesmente obtém uma nova.

Claro que você pode fazer isso com um ForEach(que não é LINQ, a propósito, mas uma extensão ativada List<T>). Mas isso literalmente usa de foreachqualquer maneira, mas com uma expressão lambda. Além disso, todo método LINQ interage internamente sua coleção, por exemplo, usando foreachoufor , no entanto, simplesmente a oculta do cliente. Eu não considero isso mais legível nem sustentável (pense em editar seu código enquanto depura um método que contém expressões lambda).

Dito isto, não deve usar o LINQ para modificar itens em sua coleção. Uma maneira melhor é a solução que você já forneceu na sua pergunta. Com um loop clássico, você pode facilmente iterar sua coleção e atualizar seus itens. De fato, todas essas soluções baseadas emList.ForEach não são nada diferentes, mas muito mais difíceis de ler da minha perspectiva.

Portanto, você não deve usar o LINQ nos casos em que deseja atualizar os elementos da sua coleção.

Eu tentei algumas variações e continuo voltando à solução desse cara.

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

Novamente, esta é a solução de outra pessoa. Mas compilei o código em uma pequena biblioteca e o uso com bastante regularidade.

Vou colar o código dele aqui, para a chance de que seu site (blog) deixe de existir em algum momento no futuro. (Não há nada pior do que ver uma postagem que diz "Aqui está a resposta exata de que você precisa", Clique e URL morto.)

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

Não, o LINQ não suporta uma maneira de atualização em massa. A única maneira mais curta seria usar um ForEachmétodo de extensão - Por que não existe o método de extensão ForEach no IEnumerable?

Eu escrevi alguns métodos de extensão para me ajudar com isso.

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

Estou usando assim:

        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

Para referência ao argumento, verifique:

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

    }
}

Meus 2 centavos: -

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

Você pode usar o LINQ para converter sua coleção em uma matriz e depois chamar Array.ForEach ():

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

Obviamente, isso não funcionará com coleções de estruturas ou tipos embutidos, como números inteiros ou cadeias.

Aqui está o método de extensão que eu uso ...

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

Eu suponho que você queira alterar valores dentro de uma consulta para poder escrever uma função para ela

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

Mas não se preocupe se é isso que você quer dizer.

Você pode usar o Magiq , uma estrutura de operação em lote para o LINQ.

Suponha que tenhamos dados como abaixo,

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

e se quisermos modificar a lista e substituir os valores existentes da lista por valores modificados, primeiro crie uma nova lista vazia e, em seguida, percorra a lista de dados chamando o método de modificação em cada item da lista,

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;