Aktualisieren Sie alle Objekte in einer Sammlung mit LINQ

Gibt es eine Möglichkeit, mit LINQ Folgendes zu tun?

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

Zur Verdeutlichung möchte ich jedes Objekt in einer Sammlung durchlaufen und dann eine Eigenschaft für jedes Objekt aktualisieren.

Mein Anwendungsfall ist, dass ich eine Reihe von Kommentaren zu einem Blog-Beitrag habe. Ich möchte jeden Kommentar in einem Blog-Beitrag durchlaufen und die Datums- und Uhrzeitangabe für den Blog-Beitrag auf +10 Stunden festlegen. Ich könnte es in SQL tun, aber ich möchte es in der Geschäftsschicht behalten.

Sie können zwar eine ForEachErweiterungsmethode verwenden, aber wenn Sie nur das Framework verwenden möchten, können Sie dies tun

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

Das ToListwird benötigt, um die Auswahl aufgrund der verzögerten Auswertung sofort auszuwerten .

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

Ich mache das

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

Ich habe tatsächlich eine Erweiterungsmethode gefunden, die das macht, was ich will

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

Verwenden:

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

Ich bin nicht sicher, ob dies LINQ überbeansprucht oder nicht, aber es hat bei mir funktioniert, wenn ich bestimmte Elemente in der Liste für eine bestimmte Bedingung aktualisieren möchte.

Hierfür gibt es keine integrierte Erweiterungsmethode. Obwohl die Definition eines ziemlich einfach ist. Am Ende des Beitrags befindet sich eine von mir definierte Methode namens Iterate. Es kann so verwendet werden

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

Quelle iterieren

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

Obwohl Sie speziell nach einer LINQ-Lösung gefragt haben und diese Frage ziemlich alt ist, poste ich eine Nicht-LINQ-Lösung. Dies liegt daran, dass LINQ (= sprachintegrierte Abfrage ) für Abfragen in Sammlungen verwendet werden soll. Alle LINQ-Methoden haben die zugrunde liegende Sammlung nicht ändern, sie einfach zurückgeben einen neuen (oder genauer gesagt einen Iterator auf eine neue Sammlung). Was auch immer Sie tun, z. B. mit a, Selectwirkt sich nicht auf die zugrunde liegende Sammlung aus, Sie erhalten einfach eine neue.

Natürlich könnten Sie es mit einem machen ForEach(was übrigens nicht LINQ ist, sondern eine Erweiterung auf List<T>). Aber das buchstäblich verwendet foreachsowieso, aber mit einem Lambda-Ausdruck. Abgesehen davon iteriert jede LINQ-Methode Ihre Sammlung intern, z. B. mithilfe von foreachoder for, verbirgt sie jedoch einfach vor dem Client. Ich halte dies nicht für lesbarer oder wartbarer (denken Sie daran, Ihren Code zu bearbeiten, während Sie eine Methode debuggen, die Lambda-Ausdrücke enthält).

Allerdings sollte LINQ nicht zum Ändern von Elementen in Ihrer Sammlung verwendet werden. Ein besserer Weg ist die Lösung, die Sie bereits in Ihrer Frage angegeben haben. Mit einer klassischen Schleife können Sie Ihre Sammlung einfach iterieren und ihre Elemente aktualisieren. Tatsächlich sind all diese Lösungen, auf die man sich stützt, List.ForEachnichts anderes, aber aus meiner Sicht weitaus schwieriger zu lesen.

Daher sollten Sie LINQ nicht in den Fällen verwenden, in denen Sie die Elemente Ihrer Sammlung aktualisieren möchten .

Ich habe ein paar Variationen davon ausprobiert und gehe immer wieder auf die Lösung dieses Typen zurück.

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

Auch dies ist die Lösung eines anderen. Aber ich habe den Code in eine kleine Bibliothek kompiliert und verwende ihn ziemlich regelmäßig.

Ich werde seinen Code hier einfügen, damit seine Website (Blog) irgendwann nicht mehr existiert. (Es gibt nichts Schlimmeres als einen Beitrag mit den Worten "Hier ist die genaue Antwort, die Sie benötigen", "Klicken" und "Tote 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; } );

Nein, LINQ unterstützt keine Art der Massenaktualisierung. Die einzige kürzere Möglichkeit wäre die Verwendung einer ForEachErweiterungsmethode. Warum gibt es in IEnumerable keine ForEach-Erweiterungsmethode?

Ich habe einige Erweiterungsmethoden geschrieben, um mir dabei zu helfen.

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

Ich benutze es so:

        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

Als Referenz überprüfen Sie das Argument:

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

    }
}

Meine 2 Pennies: -

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

Sie können LINQ verwenden, um Ihre Sammlung in ein Array zu konvertieren und dann Array.ForEach () aufzurufen:

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

Offensichtlich funktioniert dies nicht mit Sammlungen von Strukturen oder eingebauten Typen wie Ganzzahlen oder Zeichenfolgen.

Hier ist die Erweiterungsmethode, die ich verwende ...

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

Ich gehe davon aus, dass Sie Werte innerhalb einer Abfrage ändern möchten, damit Sie eine Funktion dafür schreiben können

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

Aber nicht sicher, ob du das meinst.

Sie können Magiq verwenden , ein Batch-Operations-Framework für LINQ.

Angenommen, wir haben Daten wie unten,

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

und wenn wir die Liste ändern und die vorhandenen Werte der Liste durch geänderte Werte ersetzen möchten, erstellen Sie zuerst eine neue leere Liste und durchlaufen dann die Datenliste, indem Sie die Änderungsmethode für jedes Listenelement aufrufen.

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;