Perbarui semua objek dalam koleksi menggunakan LINQ

Apakah ada cara untuk melakukan hal berikut ini menggunakan LINQ?

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

Untuk memperjelas, saya ingin mengulangi setiap objek dalam koleksi dan kemudian memperbarui properti pada setiap objek.

Kasus penggunaan saya adalah saya memiliki banyak komentar pada posting blog, dan saya ingin mengulangi setiap komentar pada posting blog dan mengatur datetime pada posting blog menjadi 10 jam. Saya bisa melakukannya dalam SQL, tetapi saya ingin menyimpannya di lapisan bisnis.

Meskipun Anda dapat menggunakan ForEachmetode ekstensi, jika Anda ingin menggunakan hanya kerangka yang bisa Anda lakukan

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

The ToListdiperlukan dalam rangka untuk mengevaluasi memilih segera karena malas evaluasi .

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

Saya melakukan ini

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

Saya benar-benar menemukan metode ekstensi yang akan melakukan apa yang saya inginkan dengan baik

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

Menggunakan:

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

Saya tidak yakin apakah ini menggunakan LINQ secara berlebihan atau tidak, tetapi ini berhasil bagi saya ketika ingin memperbarui item tertentu dalam daftar untuk kondisi tertentu.

Tidak ada metode ekstensi bawaan untuk melakukan ini. Meskipun mendefinisikan satu cukup lurus ke depan. Di bagian bawah posting adalah metode yang saya definisikan disebut Iterate. Itu bisa digunakan seperti itu

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

Sumber Iterate

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

Meskipun Anda secara khusus meminta solusi LINQ dan pertanyaan ini sudah cukup lama saya memposting solusi non-LINQ. Ini karena LINQ (= query terintegrasi bahasa ) dimaksudkan untuk digunakan untuk kueri pada koleksi. Semua metode LINQ tidak mengubah koleksi yang mendasarinya, mereka hanya mengembalikan yang baru (atau iterator yang lebih tepat ke koleksi baru). Jadi, apa pun yang Anda lakukan misalnya dengan Selecttidak mempengaruhi koleksi yang mendasarinya, Anda cukup mendapatkan yang baru.

Tentu saja Anda bisa melakukannya dengan ForEach(yang bukan LINQ, tetapi, ekstensi pada List<T>). Tapi ini benar-benar menggunakan foreach, tetapi dengan ekspresi lambda. Terlepas dari ini, setiap metode LINQ secara internal mengulang koleksi Anda, misalnya dengan menggunakan foreachatau for, namun itu menyembunyikannya dari klien. Saya tidak menganggap ini lebih mudah dibaca atau dipelihara (bayangkan mengedit kode Anda saat debugging metode yang mengandung ekspresi lambda).

Setelah mengatakan ini seharusnya tidak menggunakan LINQ untuk memodifikasi item dalam koleksi Anda. Cara yang lebih baik adalah solusi yang sudah Anda berikan dalam pertanyaan Anda. Dengan loop klasik, Anda dapat dengan mudah mengulang koleksi Anda dan memperbarui item-itemnya. Sebenarnya semua solusi yang diandalkan List.ForEachitu tidak berbeda, tetapi jauh lebih sulit untuk dibaca dari sudut pandang saya.

Jadi Anda tidak boleh menggunakan LINQ dalam kasus-kasus di mana Anda ingin memperbarui elemen koleksi Anda.

Saya sudah mencoba beberapa variasi dalam hal ini, dan saya terus kembali ke solusi orang ini.

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

Sekali lagi, ini adalah solusi orang lain. Tapi saya sudah mengkompilasi kode ke perpustakaan kecil, dan menggunakannya secara teratur.

Saya akan menempelkan kodenya di sini, untuk kemungkinan situsnya (blog) tidak ada lagi di masa mendatang. (Tidak ada yang lebih buruk daripada melihat posting yang mengatakan "Inilah jawaban tepat yang Anda butuhkan", Klik, dan URL Mati.)

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

Tidak, LINQ tidak mendukung cara pembaruan massal. Satu-satunya cara yang lebih pendek adalah dengan menggunakan ForEachmetode ekstensi - Mengapa tidak ada metode ekstensi ForEach di IEnumerable?

Saya menulis beberapa metode ekstensi untuk membantu saya.

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

Saya menggunakannya seperti ini:

        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

Untuk referensi cek argumen:

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

    }
}

2 sen saya: -

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

Anda bisa menggunakan LINQ untuk mengonversi koleksi Anda menjadi sebuah array dan kemudian memanggil Array.ForEach ():

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

Jelas ini tidak akan berfungsi dengan koleksi struct atau tipe inbuilt seperti integer atau string.

Berikut adalah metode ekstensi yang saya gunakan ...

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

Saya berasumsi Anda ingin mengubah nilai di dalam kueri sehingga Anda bisa menulis fungsi untuk itu

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

Tetapi jangan shure jika ini yang Anda maksud.

Anda bisa menggunakan Magiq , kerangka operasi batch untuk LINQ.

Misalkan kita memiliki data seperti di bawah ini,

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

dan jika kita ingin memodifikasi daftar dan mengganti nilai daftar yang ada dengan nilai yang dimodifikasi, maka pertama-tama buat daftar kosong baru, kemudian lewati daftar data dengan menerapkan metode modifikasi pada setiap item daftar,

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;