is there a .Each() (or .ForEach() ) iterator in the .Net standard library? [duplicate]

This question already has answers here: 开发者_开发百科 Closed 9 years ago.

Possible Duplicate:

LINQ equivalent of foreach for IEnumerable<T>

I'm wondering whether there is a method for IEnumerable like the following .Each() in the .Net library

var intArray = new [] {1, 2, 3, 4};
intArrary.Each(Console.WriteLine);

I know I can use a foreach loop or easily write an extension method like this:

public static class EnumerableExtensions
{
    public static void Each<T>(this IEnumerable<T> enumberable, Action<T> action)
    {
        foreach (var item in enumberable)
        {
            action(item);
        }
    }
}

But I'm hoping not to create my own method to mess up code if there is already such an extension method in the library. And something like .Each() (with a few overloadings which can take conditions as extra params) is heavily needed by programmers, and there should already be one. Am I correct?

Update

Ruby developers may recognize it as a .each() iterator. And that's what I hope to have in C#. Maybe C# can have more iterator methods like those in Ruby.

---

As others have said there is none built in on IEnumerable<T>. The Linq team was against it as per this post by Eric Lippert:: http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx

There is a static method on Array.ForEach and List<T> has an instance method. There is also in PLINQ foreach like statements, but be warned that they work in parallel and can lead to very bad performance for extremely simple actions. Here is one such method in PLINQ: http://msdn.microsoft.com/en-us/library/dd383744.aspx

And here is a guide on PLINQ in general: http://msdn.microsoft.com/en-us/library/dd460688.aspx

While I can't find the exact article if you poke around in the ParrallelEnumerable section it gives warnings and tips as to how to improve the performance of using parallelism in code

If you want it, I suggest creating 2 versions, one that include indexer and one without. This can be quite useful and can save a select statement to acquire the index. e.g.

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

public static void ForEach<T>(IEnumerable<T> enumerable,Action<T,int> action)
{
    int index = 0;
    foreach(var item in enumerable) action(item,index++);
}

I'd also include argument validation as these are public methods.

---

Yes there is.

someList.ForEach(x => Console.WriteLine(x));

Or with an array:

Array.ForEach(someArray, x => Console.WriteLine(x));

Note that in this last example you have to call the static method on the Array class

EDIT: The namespaces are: System.Collections.Generic for the List method and System for the Array method

---

There's a ForEach method on System.Collections.List< T >, but not on IEnumerable. Note, this is also not part of LINQ (it was already there in .NET 2.0).

At first glance you'd expect this to be part of LINQ, as it's sort of an extension on the normal List functionality. However, LINQ is more about grouping, filtering and converting data. If you look closely, most (if not all, I'm not Jon Skeet, I don't know that stuff by heart!) LINQ methods return some sort of IEnumerable.

However, you might want to take a look at MoreLinq. This is an open-source project which adds some key features to the existing LINQ to Objects, one of which is the ForEach method you want (works on any IEnumerable in this case, so it'll work on your array as well).

---

No, there isn't, unfortunately. (I think this question has been discussed before, but I can't find it currently.)

Due to some bizarre accident of history, the ForEach method ended up on List<T>, instead of IEnumerable<T>, where it would make more sense, and because of backwards-compatiblity, this can never ever be fixed.

Ever since extension methods existed, adding a ForEach(this IEnumerable<T>, ...) extension method was requested over and over again, but it is usually rejected because it would lead to confusing behavior: since instance methods are always selected before extension methods, this would mean that all IEnumerables get treated identically, except for Lists and they wouldn't allow such inconsistencies in the BCL.

As a result, pretty much every .NET project on the planet now starts off with exactly the code you described above:

namespace IEnumerableExtensions
{
    public static class IEnumerableExtensions
    {
        public static void ForEach<T>(this IEnumerable<T> xs, Action<T> f)
        {
            foreach (var x in xs) f(x);
        }
    }
}

---

Only List<T> provides a ForEach method - for all other types you will have to roll your own extension method.

---

it depends on the framework version

.net 3.5 and 4.0 have a ForEach method