Mettre à jour tous les objets d'une collection à l'aide de LINQ

Existe-t-il un moyen d'effectuer les opérations suivantes à l'aide de LINQ?

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

Pour clarifier, je veux parcourir chaque objet d'une collection, puis mettre à jour une propriété sur chaque objet.

Mon cas d'utilisation est que j'ai un tas de commentaires sur un article de blog, et je veux parcourir chaque commentaire sur un article de blog et définir la date / heure sur l'article de blog à +10 heures. Je pourrais le faire en SQL, mais je veux le garder dans la couche métier.

Bien que vous puissiez utiliser une ForEachméthode d'extension, si vous souhaitez utiliser uniquement le framework, vous pouvez le faire

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

Le ToListest nécessaire pour évaluer la sélection immédiatement en raison d'une évaluation paresseuse .

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

Je fais ça

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

J'ai trouvé une méthode d'extension qui fera ce que je veux bien

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

Utilisation:

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

Je ne sais pas si cela utilise trop LINQ ou non, mais cela a fonctionné pour moi lorsque je voulais mettre à jour un élément spécifique de la liste pour une condition spécifique.

Il n'y a pas de méthode d'extension intégrée pour ce faire. Bien que la définition de l'un soit assez simple. Au bas du message, il y a une méthode que j'ai définie appelée Iterate. Il peut être utilisé comme tel

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

Itérer la 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++;
    }
}

Bien que vous ayez spécifiquement demandé une solution LINQ et que cette question soit assez ancienne, je poste une solution non LINQ. En effet, LINQ (= requête intégrée de langue ) est destiné à être utilisé pour les requêtes sur les collections. Toutes les méthodes LINQ ne modifient pas la collection sous-jacente, elles en renvoient juste une nouvelle (ou plus précisément un itérateur dans une nouvelle collection). Ainsi, quoi que vous fassiez par exemple avec un Selectn'affecte pas la collection sous-jacente, vous en obtenez simplement une nouvelle.

Bien sûr toi pouvez le faire avec un ForEach(qui n'est pas LINQ, soit dit en passant, mais une extension activée List<T>). Mais cela utilise littéralement deforeach toute façon, mais avec une expression lambda. En dehors de cela, chaque méthode LINQ itère en interne votre collection, par exemple en utilisant foreachou for, mais elle la cache simplement au client. Je ne considère pas cela plus lisible ni maintenable (pensez à éditer votre code tout en déboguant une méthode contenant des expressions lambda).

Cela dit, cela ne devrait pas utiliser LINQ pour modifier les éléments de votre collection. Une meilleure façon est la solution que vous avez déjà fournie dans votre question. Avec une boucle classique, vous pouvez facilement itérer votre collection et mettre à jour ses articles. En fait, toutes ces solutions qui List.ForEachcomptent ne sont pas différentes, mais beaucoup plus difficiles à lire de mon point de vue.

Vous ne devez donc pas utiliser LINQ dans les cas où vous souhaitez mettre jour les éléments de votre collection.

J'ai essayé quelques variantes à ce sujet, et je reviens toujours à la solution de ce type.

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

Encore une fois, c'est la solution de quelqu'un d'autre. Mais j'ai compilé le code dans une petite bibliothèque et je l'utilise assez régulièrement.

Je vais coller son code ici, pour la chance que son site (blog) cesse d'exister à un moment donné dans le futur. (Il n'y a rien de pire que de voir un article qui dit "Voici la réponse exacte dont vous avez besoin", Click et URL morte.)

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

Non, LINQ ne prend pas en charge une méthode de mise à jour en masse. Le seul moyen plus court serait d'utiliser une ForEachméthode d'extension - Pourquoi n'y a-t-il pas de méthode d'extension ForEach sur IEnumerable?

J'ai écrit quelques méthodes d'extension pour m'aider.

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

Je l'utilise comme ceci:

        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

Pour référence, la vérification des arguments:

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

    }
}

Mes 2 centimes: -

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

Vous pouvez utiliser LINQ pour convertir votre collection en un tableau, puis appeler Array.ForEach ():

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

Évidemment, cela ne fonctionnera pas avec des collections de structures ou de types intégrés comme des entiers ou des chaînes.

Voici la méthode d'extension que j'utilise ...

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

Je suppose que vous souhaitez modifier les valeurs dans une requête afin que vous puissiez écrire une fonction pour elle

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

Mais ne vous inquiétez pas si c'est ce que vous voulez dire.

Vous pouvez utiliser Magiq , un framework d'opérations par lots pour LINQ.

Supposons que nous ayons des données comme ci-dessous,

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

et si nous voulons modifier la liste et remplacer les valeurs existantes de la liste par des valeurs modifiées, créer d'abord une nouvelle liste vide, puis parcourir la liste de données en appelant la méthode de modification sur chaque élément de la liste,

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;