249

Is there any Linq style syntax for "For each" operations?

For instance, add values based on one collection to another, already existing one:

IEnumerable<int> someValues = new List<int>() { 1, 2, 3 };

IList<int> list = new List<int>();

someValues.ForEach(x => list.Add(x + 1));

Instead of 

foreach(int value in someValues)
{
  list.Add(value + 1);
}
Samuel Liew
  • 76,741
  • 107
  • 159
  • 260
Stefan Steinegger
  • 63,782
  • 15
  • 129
  • 193
  • 4
    See also this blog post from Eric Lippert, regarding the rationale for not including `ForEach` in the BCL: http://blogs.msdn.com/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx – LukeH Oct 02 '09 at 13:28
  • http://stackoverflow.com/questions/200574/linq-equivalent-of-foreach-for-ienumerable – aku Oct 02 '09 at 13:18
  • 1
    Original link to Eric Lippert's blog post is dead. [Wayback machine link](https://web.archive.org/web/20100220102439/http://blogs.msdn.com/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx). – Tim Partridge Jun 03 '22 at 21:47

6 Answers6

348

Using the ToList() extension method is your best option:

someValues.ToList().ForEach(x => list.Add(x + 1));

There is no extension method in the BCL that implements ForEach directly.

Although there's no extension method in the BCL that does this, there is still an option in the System namespace... if you add Reactive Extensions to your project:

using System.Reactive.Linq;

someValues.ToObservable().Subscribe(x => list.Add(x + 1));

This has the same end result as the above use of ToList, but is (in theory) more efficient, because it streams the values directly to the delegate.

Mark Seemann
  • 225,310
  • 48
  • 427
  • 736
  • 4
    Bear in mind that this isn't ideal for a very long list, as it makes a copy of the entire list before looping through it. – Daniel Earwicker Oct 02 '09 at 13:32
  • 11
    Calling `ToList` followed by `ForEach` involves iterating through the original collection twice. I'd prefer a standard `foreach` loop any day: less typing, more readable and better performance: `foreach (var x in someValues) list.Add(x + 1);` – LukeH Oct 02 '09 at 13:35
  • 53
    For anyone who sees this and thinks its a good answer, its not. It is crazy inefficient. See Noldorin's answer for the correct way to do things. – Steve Oct 02 '09 at 14:26
  • 1
    @Steve: Thanks for pointing that out. Indeed, this is not the best solution because it means the collection is iterated over twice, and memory is temporarily allocated for the `List`, adding more overhead! – Noldorin Oct 02 '09 at 14:33
  • @Stefan: Not sure how mine was not "correct". You really don't want to be using this less performant method just because it saves you writing a 3 line extension method. – Noldorin Oct 02 '09 at 14:35
  • 11
    Fair points all, but I'd like to add this: It may be inefficient in theory, but most in-memory lists I work with tend to have less than a dozen items. Perf. problems are usually somewhere else, so I think it is a premature optimization to categorically state that this answer is bad. The question was whether this *syntax* is available, and this is as close as you get on plain vanilla .NET 3.5 SP1 without writing the extension method yourself. I would love to have a ForEach extension method in the BCL, but it's not available in the current framework. – Mark Seemann Oct 02 '09 at 14:42
  • @Mark: Your code's ineffiency might be forgivable if it was more readable/understandable/intuitive than the alternatives, but it's not. What's the benefit of using your code rather than a standard `foreach` loop? – LukeH Oct 02 '09 at 15:06
  • 2
    @Luke: There's no particular benefit, but that wasn't the question either. In any case I think this is a storm in a teacup: in most cases I bet you can't feel the perf diff at all. – Mark Seemann Oct 02 '09 at 15:12
  • Yeah, I wouldn't be complaining about the performance either, if the more efficient solution weren't so very simple. (Using the foreach loop or a short extension method.) Meh, I haven't down-voted anyway. – Noldorin Oct 02 '09 at 15:19
  • 2
    @MarkSeemann in my testing the new answer of `someValues.ToObservable().Subscribe(...)` seems to be around 50 times slower than `ToList().ForEach(...)` and `Select(...).ToList()` – qujck Jan 06 '14 at 16:44
  • 2
    @qujck but *in theory*, it's much more efficient! ;) – Mark Seemann Jan 06 '14 at 16:50
  • 1
    Honestly – and I'm trying to be constructive here – I think the addendum that converts to an Observable and attaches a Subscriber just for a `foreach` brought an already questionable answer into "wrong" answer territory – forresthopkinsa Jan 09 '21 at 03:49
125

The Array and List<T> classes already have ForEach methods, though only this specific implementation. (Note that the former is static, by the way).

Not sure it really offers a great advantage over a foreach statement, but you could write an extension method to do the job for all IEnumerable<T> objects.

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
    foreach (var item in source)
        action(item);
}

This would allow the exact code you posted in your question to work just as you want.

Noldorin
  • 144,213
  • 56
  • 264
  • 302
  • 2
    Thanks, It's clear that I could write the extension myself. I just want to use built in stuff as far as possible before doing this. – Stefan Steinegger Oct 02 '09 at 13:28
  • 4
    Yeah, that's fair enough. I also make sure I'm not reinventing BCL functionality too. In this case, there's none however. – Noldorin Oct 02 '09 at 13:39
  • 3
    Array class doesn't have a ForEach method :) but there is a "EnumerableExtensions" statşc class in Microsoft.Practices.ObjectBuilder2 namespace. it has foreach method for IEnumerable :) – DLL_Whisperer Mar 23 '16 at 17:15
37

There isn't anything built-in, but you can easily create your own extension method to do it:

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
    if (source == null) throw new ArgumentNullException("source");
    if (action == null) throw new ArgumentNullException("action");

    foreach (T item in source)
    {
        action(item);
    }
}
LukeH
  • 263,068
  • 57
  • 365
  • 409
21

The official MS line is "because it's not a functional operation" (ie it's a stateful operation).

Couldn't you do something like:

list.Select( x => x+1 )

or if you really need it in a List:

var someValues = new List<int>( list.Select( x => x+1 ) );
stusmith
  • 14,003
  • 7
  • 56
  • 89
  • 7
    You have a point about functional vs. stateful operations. However, F# was designed as a functional length, and has an equivalent `ForEach` method. – Noldorin Oct 02 '09 at 13:25
  • 1
    Can you give a reference for "The official MS line"? I'm interested in reading the rest of their take. – gabe Jun 21 '18 at 22:16
  • 1
    I probably shouldn't have used the word "official", but this is the blog I was thinking of: https://blogs.msdn.microsoft.com/ericlippert/2009/05/18/foreach-vs-foreach/ – stusmith Jul 02 '18 at 16:14
6

There is no Linq ForEach extension. However, the List class has a ForEach method on it, if you're willing to use the List directly.

For what it's worth, the standard foreach syntax will give you the results you want and it's probably easier to read:

foreach (var x in someValues)
{
    list.Add(x + 1);
}

If you're adamant you want an Linq style extension. it's trivial to implement this yourself.

public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action)
{
   foreach (var x in @this)
      action(x);
}
dustyburwell
  • 5,755
  • 2
  • 27
  • 34
4

There isn't anything like that in standard Linq, but there is a ForEach operator in MoreLinq.

R. Martinho Fernandes
  • 228,013
  • 71
  • 433
  • 510