foreach loop vs. ForEach method - Differences? [duplicate]

Question

EDIT: This question can be marked as a duplicate of this question.

Is there any differences (performance or otherwise) between using a foreach loop or the ForEach LINQ method?

For context, this is part of one of my methods:

foreach (var property in typeof(Person).GetProperties())
{
    Validate(property.Name);
}

I can alternatively use this code to perform the same task:

typeof(Person)
    .GetProperties()
    .ToList()
    .ForEach(property => Validate(property.Name));

When would be using the loop structure be better than using method chaining?

Here's another example where I've used the ForEach method, but could just have easily used a foreach loop and a variable:

// LINQ
PrivateData.Database.Users
           .Cast<User>()
           .Where(user => user.LoginType == LoginType.WindowsUser)
           .Select(user => new { Name = user.Name, Login = user.Login })
           .ToList()
           .ForEach(result => WriteObject(result));

// Loop
var users = PrivateData.Database.Users
               .Cast<User>()
               .Where(user => user.LoginType == LoginType.WindowsUser)
               .Select(user => new { Name = user.Name, Login = user.Login });

foreach(var user in users)
{
    WriteObject(user);
}

Answer 1

I would defer you to Eric Lipperts blog "foreach" vs "ForEach". As the previous principal developer on the C# compiler team, I think his opinion is spot on.

Excerpt: (referring to .ForEach())

The first reason is that doing so violates the functional programming principles that all the other sequence operators are based upon. Clearly the sole purpose of a call to this method is to cause side effects. The purpose of an expression is to compute a value, not to cause a side effect. The purpose of a statement is to cause a side effect. The call site of this thing would look an awful lot like an expression (though, admittedly, since the method is void-returning, the expression could only be used in a “statement expression” context.) It does not sit well with me to make the one and only sequence operator that is only useful for its side effects.

Answer 2

The loop is better style because it is a tool made exactly for what you want to do. It integrates nicer with the language. For example, you can break from a loop. Tools understand loops, they do not understand ForEach.

The loop is easier to understand for humans as well. ForEach is very uncommon.

The loop also is faster because there are less indirect calls, less delegate allocations and the optimizer can see more of what you are doing in one place. It also saves the ToList call. You could save that call by writing a custom extension method on IEnumerable<T> as well.

I think the loop is superior in all cases that I can think of. Maybe there's some corner case where the ForEach method would be better style or more convenient for some reason.

PLINQ also has a ForAll which is required for efficiency reasons because it can be parallelized.