How many times I read: “In C# reference types are passed by reference, primitive types by value”? The essential point is that reference types has nothing to do with passing by reference!

But let us start with some basics. There are two types of objects, the value types (structs) where the variable is the object and the reference types which only points to the object. When you pass in a variable to a method, its value gets copied to the method by default. For values types, that means the object itself gets copied. For reference types, that means only the thing that points at the object gets copied!

It is a little bit confusing, because only the reference to the object is copied, not the entire structure. It is a way to save performance, otherwise as larger as the reference type would be as more performance it would cost. This strategy is also know as call by sharing (which makes it a less confusing than calling it also call by value with reference types). So in a call by value scenario, if the data of a reference type is changed inside the method, the caller variable is also affected. If you change a the value of a value type, which is passed to a method, it will not affect the caller variable.

public void Sample()
{
    Point point = new Point(20, 30);
    Person person = new Person() { Name = "Meier" };

    CallByValue(point, person); 

    Console.WriteLine("Point X: {0}", point.X);
    Console.WriteLine("Name: {0}", person.Name); 
}

public void CallByValue(Point point, Person person)
{
    point.X = 10;
    person.Name = "Müller"; 
}

The ref keyword indicates in C# a call by reference. When pass a value type by reference to a method, the changes to the value which are done in the method scope, will also affect the variable in the code of the caller. But what happens if you pass reference type to a method by ref?

public void Sample()
{
    Point point = new Point(20, 30);
    Person person = new Person() { Name = "Meier" };

    CallByValue(ref point, ref person); 

    Console.WriteLine("Point X: {0}", point.X);
    Console.WriteLine("Name: {0}", person.Name); 
}

public void CallByValue(ref Point point, ref Person person)
{
    point.X = 10;
    person = new Person() { Name = "Müller" };
}

It allows to change the instance which the variable points to. So you can assign a new object to the variable and also the caller variable will point to the new object. By the way the behaviour in VB.NET is similar to the behaviour of C#, the only difference is that in VB.NET you always have to define if you want to pass a value by value or reference.

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.

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 loops over all stored Points in the collection. It substracts 10 from the x coordinate of the point. At the end the Points will be printed to the console.

List<Point> points = new List<Point>()
{ 
  new Point(14, 10), 
  new Point(19, 10) 
};

items.ForEach(point => point.X = point.X - 10);

foreach (Point point in points)
{
   Console.WriteLine(point);
}

The output in the console is in this case {X=14, Y=10} and {X=19, Y=10}. I expected that X is 4 and 9, so what’s wrong? If you put the same logic into a normal foreach statement the compiler throws the following error: “Cannot modify members of ‘point’ because it is a ‘foreach iteration variable’”. If we define our own type, the code does what it should do! 

public class MyPoint
{
   public MyPoint(int x, int y){ X = x; Y = y; }
   public int X{ get; set; }
   public int Y{ get; set; }
}

List<MyPoint> points = new List<MyPoint>()
{ 
  new MyPoint(14, 10), 
  new MyPoint(19, 10) 
};

items.ForEach(point => point.X = point.X - 10);

foreach (MyPoint point in points)
{
   Console.WriteLine(point);
}

The difference is, that Point is a value type, a struct, and MyPoint is a reference type. So in the case where Point is used, 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.

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 result should be 4 and 9! It seems that internally a for loop is is used, which iterates backward over the collection. 

Conclusion

So List<T>.ForEach allows several things which is blocked in a foreach loop. These things aren’t allowed for a good reason. So if you want to store objects of value types, like int, long, double, bool or even string,  in a generic List, you shouldn’t use the ForEach method if you want to avoid problems. A good solution is use a for loop and access the data over the indexer of the collection. Also removing items in the ForEach method is a thing which should be avoided also when it is possible.