List(T).ForEach or foreach, it doesn't matter...or does it?

Introduction

In C# you have various possibilities to iterate over a list like for loop, foreach loop or with LINQ. When you use a List(T) type you have even one more, the ForEach method. But this method doesn't show always the same behaviour than a normal foreach loop.

Using the code 

The ForEach method of the List<T> (not IList<T>) executes an operation for every object which is stored in the list. Normally it contains code to either read or modify every object which is in the list or to do something with list itself for every object.

Modify the object itself 

The following sample with a ForEach method iterates over all stored numbers in the collection. It substracts 10 from every number. At the end the numbers will be printed to the console. Wether it works depends on which data type you use!

List<int> items = new List<int>() { 14, 19 };
items.ForEach(item => item = item - 10);
foreach (int item in items)
{
    Console.WriteLine(item);
}

The output in the console is in this case 14 and 19. If the type is a primitive data type (a struct in .NET), the ForEach method doesn't have the effect you want. I didn't expect this result, but after a look at the ForEach definition it becomes clearer. It can't work by design!

//Definition of List<T>.ForEach
public void ForEach(Action<T> action)
//Definition of Action<T>
public delegate void Action<in T>(T obj)
Int is a value type which means, that it is passed to a method by value. By value means the a copy of the object is passed to the method, not the object itself. So if the action, which is passed into the ForEach method, changes the copy, but it won't affect the original object. So in our sample, the original int value won't be changed. The Action delegate also doesn't have a return type, which could be used to update the object in the list.

Modify the collection

When you use a normal foreach statement, you can't add or remove items while iterating over the collection. But with List.ForEach you can, so the following code can be executed without any errors. Which result do you expect?

public class Integer
{
    public int Value { get; set; }
    public Integer(int value) { Value = value; }
}
public void Sample()
{
    List<Integer> items = new List<Integer>()
    {
        new Integer(14),
        new Integer(0),
        new Integer(19)
    };
    items.ForEach(item =>
    {
        if (item.Value == 0)
        {
            items.Remove(item);
        }
        item.Value = item.Value - 10;
    });
    foreach (Integer item in items)
    {
        Console.WriteLine(item.Value);
    }
}

The result which is shown in the console is 4 and 19. So this is a good example that not all what you can do, you also should do! The other way, remove an item, works perfectly. It seems that internally a backward iteration is used, so removing works, adding doesn't.

Points of Interest

So if you want to store objects of structs, like int, long, double, bool or even string,  in a generic List, you should use normal foreach (or for) instead if you want to avoid problems. Also removing items in the ForEach method is a thing which should be avoided also when it is possible. Otherwise i promise, the time will come when someone copies you code uses the ForEach to add items instead of removing it!