Zaktualizuj wszystkie obiekty w kolekcji za pomocą LINQ

Czy istnieje sposób na wykonanie poniższych czynności przy użyciu LINQ?

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

Aby to wyjaśnić, chcę iterować po każdym obiekcie w kolekcji, a następnie zaktualizować właściwość na każdym obiekcie.

Mój przypadek użycia polega na tym, że mam kilka komentarzy do posta na blogu i chcę iterować każdy komentarz do postu na blogu i ustawić datę i godzinę na blogu na +10 godzin. Mógłbym to zrobić w SQL, ale chcę zachować to w warstwie biznesowej.

Możesz użyć ForEachmetody rozszerzenia, ale jeśli chcesz użyć tylko frameworku, możesz to zrobić

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

Jest ToListto potrzebne do natychmiastowej oceny wyboru ze względu na leniwą ocenę .

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

Robię to

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

I rzeczywiście znaleziono metodę rozszerzenia , które będą robić to, co chcę ładnie

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

Posługiwać się:

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

Nie jestem pewien, czy to nadużywa LINQ, czy nie, ale zadziałało to, gdy chcę zaktualizować określone elementy na liście dla określonego warunku.

Nie ma wbudowanej metody rozszerzenia, aby to zrobić. Chociaż zdefiniowanie jednego jest dość proste. Na dole postu znajduje się metoda, którą zdefiniowałem, o nazwie Iterate. Można go tak używać

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

Iterate Source

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

Chociaż konkretnie poprosiłeś o rozwiązanie LINQ, a to pytanie jest dość stare, zamieszczam rozwiązanie inne niż LINQ. Wynika to z tego, że LINQ (= zapytanie zintegrowane w języku ) jest przeznaczone do użycia w zapytaniach dotyczących kolekcji. Wszystkie metody LINQ nie modyfikują podstawowej kolekcji, po prostu zwracają nową (a dokładniej iterator do nowej kolekcji). Zatem cokolwiek robisz np. Z Selectnie wpływa na kolekcję, po prostu dostajesz nową.

Oczywiście możesz to zrobić za pomocą ForEach(który nie jest LINQ, ale rozszerzenie jest włączone List<T>). Ale i tak dosłownie się to stosuje foreach, ale z wyrażeniem lambda. Poza tym każda metoda LINQ wewnętrznie iteruje Twoją kolekcję, np. Przy użyciu foreachlub for, ale po prostu ukrywa ją przed klientem. Nie uważam tego za bardziej czytelny ani konserwowalny (pomyśl o edycji kodu podczas debugowania metody zawierającej wyrażenia lambda).

Powiedziawszy to, nie powinieneś używać LINQ do modyfikowania przedmiotów w swojej kolekcji. Lepszym sposobem jest rozwiązanie, które już podałeś w swoim pytaniu. Dzięki klasycznej pętli możesz z łatwością iterować swoją kolekcję i aktualizować jej elementy. W rzeczywistości wszystkie te rozwiązania, na których się opierają, List.ForEachnie są niczym innym, ale o wiele trudniejsze do odczytania z mojej perspektywy.

Dlatego nie powinieneś używać LINQ w przypadkach, w których chcesz zaktualizować elementy swojej kolekcji.

Wypróbowałem kilka wariantów tego i wracam do rozwiązania tego faceta.

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

Ponownie, jest to czyjeś rozwiązanie. Ale skompilowałem kod do małej biblioteki i używam go dość regularnie.

Wkleję tutaj jego kod, aby nie ryzykować, że jego strona (blog) przestanie istnieć w pewnym momencie w przyszłości. (Nie ma nic gorszego niż wyświetlenie postu z napisem „Oto dokładna odpowiedź, której potrzebujesz”, Kliknięcia i Martwego adresu 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; } );

Nie, LINQ nie obsługuje sposobu masowej aktualizacji. Jedynym krótszym sposobem byłoby użycie ForEachmetody rozszerzenia - Dlaczego w IEnumerable nie ma metody rozszerzenia ForEach?

Napisałem kilka metod rozszerzenia, które mi w tym pomogą.

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

Używam tego w ten sposób:

        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

Dla porównania: sprawdzenie argumentu:

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

    }
}

Moje 2 grosze: -

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

Możesz użyć LINQ, aby przekonwertować swoją kolekcję na tablicę, a następnie wywołać Array.ForEach ():

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

Oczywiście nie będzie to działać z kolekcjami struktur lub wbudowanymi typami, takimi jak liczby całkowite lub łańcuchy.

Oto metoda rozszerzenia, której używam ...

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

Zakładam, że chcesz zmienić wartości wewnątrz zapytania, aby móc dla niego napisać funkcję

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

Ale nie martw się, jeśli o to ci chodzi.

Możesz użyć Magiq , frameworku operacji wsadowych dla LINQ.

Załóżmy, że mamy dane takie jak poniżej,

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

a jeśli chcemy zmodyfikować listę i zastąpić istniejące wartości listy zmodyfikowanymi wartościami, najpierw utwórz nową pustą listę, a następnie przejrzyj listę danych, wywołując metodę modyfikacji dla każdego elementu listy,

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;