Executing a certain action for all elements in an Enumerable<T>

Question

I'm getting started with C# 3.0 and LINQ, and I can't find a feature that to me is obvious, it's gotta be there.

I have an Enumerable, and I want to execute something for each instance of it. Something like...

string[] Names = ...; Names.each(s => Console.Writeline(s));

or

Names.each(s => GenHTMLOutput(s));
// (where GenHTMLOutput cannot for some reason receive the enumerable itself as a parameter)

Kind of like .Select() but for doing something instead of returning something.
I did try .Select(s=> { Console.WriteLine(s); return s; }), but it wasn't printing anything.

Answer 1

If you don't want to add your own extension method, try .All(). It takes a Predicate rather than an Action, so you'll need to return a boolean. But the semantics are still readable and it should perform a little better than converting to a list first, since you only iterate the collection once.

Answer 2

You are looking for the ever-elusive ForEach that currently only exists on the List generic collection. There are many discussions online about whether Microsoft should or should not add this as a LINQ method. Currently, you have to roll your own:

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

While the All() method provides similar abilities, it's use-case is for performing a predicate test on every item rather than an action. Of course, it can be persuaded to perform other tasks but this somewhat changes the semantics and would make it harder for others to interpret your code (i.e. is this use of All() for a predicate test or an action?).

Answer 3

There is a ForEach method off of List. You could convert the Enumerable to List by calling the .ToList() method, and then call the ForEach method off of that.

Alternatively, I've heard of people defining their own ForEach method off of IEnumerable. This can be accomplished by essentially calling the ForEach method, but instead wrapping it in an extension method:

public static class IEnumerableExtensions
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> _this, Action<T> del)
    {
        List<T> list = _this.ToList();
        list.ForEach(del);
        return list;
    }
}

Answer 4

You cannot do this right away with LINQ and IEnumerable - you need to either implement your own extension method, or cast your enumeration to an array with LINQ and then call Array.ForEach():

Array.ForEach(MyCollection.ToArray(), x => x.YourMethod());

Please note that because of the way value types and structs work, if the collection is of a value type and you modify the elements of the collection this way, it will have no effect on the elements of the original collection.

Answer 5

Unfortunately there is no built-in way to do this in the current version of LINQ. The framework team neglected to add a .ForEach extension method. There's a good discussion about this going on right now on the following blog.

http://blogs.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

It's rather easy to add one though.

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

Answer 6

Because LINQ is designed to be a query feature and not an update feature you will not find an extension which executes methods on IEnumerable<T> because that would allow you to execute a method (potentially with side effects). In this case you may as well just stick with

foreach(string name in Names)
Console.WriteLine(name);

Answer 7

A quick-and-easy way to get this is:

Names.ToList().ForEach(e => ...);