web-dev-qa-db-ja.com

LINQを使用してコレクション内のすべてのオブジェクトを更新する

LINQを使用して次のことを行う方法はありますか?

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

わかりやすくするために、コレクション内の各オブジェクトを反復処理してから、各オブジェクトのプロパティを更新します。

私のユースケースは、私がブログ投稿にたくさんのコメントを持っているということです、そして、私はブログ投稿のそれぞれのコメントを通して繰り返して、+10時間にブログ投稿の日時を設定したいです。私はSQLでそれをすることができましたが、私はビジネス層でそれを保ちたいです。

421
lomaxx

あなたはForEach拡張メソッドを使うことができますが、あなたがフレームワークだけを使いたいのであればあなたがすることができます

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

ToList 遅延評価 のためにselectを直ちに評価するために必要です。

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

私はこれをやっています

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

私は実際に 拡張メソッドを見つけました それは私がうまく欲しいことをするでしょう

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

つかいます:

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

これがLINQを使いすぎているかどうかはわかりませんが、リスト内の特定の項目を特定の条件に合わせて更新したい場合に役立ちます。

12
Hennish

これを行うための組み込みの拡張方法はありません。定義するのはかなり簡単ですが。記事の一番下に、私が定義したメソッドIterateがあります。こんな感じで使えます

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

ソースを繰り返す

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

私はこれについていくつかのバリエーションを試しました、そして私はこの男の解決策に戻り続けます。

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

繰り返しますが、これは他の誰かの解決策です。しかし、私はコードを小さなライブラリにコンパイルし、そしてそれをかなり定期的に使用しています。

彼のサイト(ブログ)が将来のある時点で存在しなくなる可能性があるため、ここに彼のコードを貼り付けます。 (「ここにあなたが必要とする正確な答えがあります」と書かれた、クリックして、そしてDead 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; } );
5
granadaCoder

いいえ、LINQは一括更新の方法をサポートしていません。唯一の より短い 方法はForEach拡張メソッドを使うことでしょう - なぜIEnumerableにForEach拡張メソッドがないのですか

3
Aaron Powell

私の2ペニー: -

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

あなたは特にlinq-solutionを求めていて、この質問はかなり古いですが、私はnon-linq-solutionを投稿しています。これは、linq(= lanuguage integrated query )がコレクションのクエリに使用されるようになっているためです。すべてのlinqメソッドは、基礎となるコレクションを修正するのではなく、単に return 新しいもの(正確には新しいコレクションへのイテレータ)を返すだけです。したがって、あなたがすることは何でも。 Selectを指定しても、基になるコレクションには影響しません。新しいコレクションを取得するだけです。

もちろん、 - ForEachでできます(ちなみにlinqではなく、List<T>の拡張子です)。しかし、これは 文字通り で、とにかくラムダ式を除いてforeachを使用しています。これとは別に every linq-methodは内部的にコレクションを繰り返します。 foreachまたはforを使用することによって、クライアントからそれを隠します。これ以上読みやすく保守しやすいとは考えていません(ラムダ式を含むメソッドをデバッグしながらコードを編集することは考えないでください)。

これは、自分のコレクションの modify itemsにLinqを使用しないことを意味します。もっと良い方法は、あなたがすでにあなたの質問で提供した解決策です。古典的なループを使用すると、コレクションを簡単に繰り返してそのアイテムを更新できます。実際、List.ForEachに頼っているこれらの解決策はすべて違いはありませんが、私の観点からは読むのがはるかに困難です。

そのため、コレクションの要素を update にしたい場合は、linqを使用しないでください。

2
HimBromBeere

私はそれを手助けするためにいくつかの拡張方法を書きました。

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 ([email protected](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;
        }
    }
}

私はこのように使っています:

        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

参考のために引数をチェックします。

/// <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
PartTimeIndie

LINQのバッチ操作フレームワークである Magiq を使用できます。

1
ivos

これが私が使っている拡張方法です。

    /// <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;
    }
1
Bill Forney

LINQを使用してコレクションを配列に変換してからArray.ForEach()を呼び出すことができます。

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

明らかにこれは構造体のコレクションや整数や文字列のような作り付けの型では動作しません。

1
Tamas Czinege

私はあなたがそれのために関数を書くことができるようにあなたが質問の中で値を変えたいと思うと思います

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

しかし、これがあなたが意味するものであるかどうか恥ずべきことではありません。

0
Stormenet

以下のようなデータがあるとします。

var items = new List<string>({"123", "456", "789"});

リストを変更してリストの既存の値を変更した値に置き換える場合は、まず新しい空のリストを作成してから、各リスト項目のmodifyメソッドを呼び出してデータリストをループ処理します。

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;
0
Vishwa G