The string s passed into the anonymous delegate is not being passed by reference, so you're setting a local scoped variable to a lowercase version and not affecting the original member of the list.

There's nothing wrong with the code, is doing exactly what you told it to do =oP

...strings are immutable

The line s = s.ToLower() is merely changing the location that the local reference s is pointing to.

Changing the local reference s will not change the original pointer haiku[x].

Change this line:
s = s.ToLower();

to this line:
haiku[haiku.IndexOf(s)] = s.ToLower();

I'm surprised at the comments that seem to think that this is caused by the fact that strings are immutable. Truthfully, the code presented wouldn't work even if they were mutable. The problem (as noted by Haaked and zproxy) is that the parameter is passed by value and not by reference.

You could define your own MutableAction delegate and corresponding MutableForEach to allow passing by reference.

Solution #1:

using System;
using System.Collections.Generic;

class WWWTC
{
delegate void MutableAction<T>(ref T item);

static void MutableForEach<T>(List<T> list, MutableAction<T> action)
{
for (int i = 0; i < list.Count; i++)
{
T item = list[i];
action(ref item);
list[i] = item;
}
}

static void Main()
{
List<string> haiku = new List<string>();

haiku.Add("All software changes");
haiku.Add("Upon further reflection -");
haiku.Add("A reference to String");

MutableForEach(haiku,
delegate(ref string s)
{
s = s.ToLower();
});

haiku.ForEach(Console.WriteLine);
}
}

Of course, it's probably best to just use the List.ConvertAll<T>() method.

Solution #2:

using System;
using System.Collections.Generic;

class WWWTC
{
static void Main()
{
List<string> haiku = new List<string>();

haiku.Add("All software changes");
haiku.Add("Upon further reflection -");
haiku.Add("A reference to String");

// make it lowercase
haiku = haiku.ConvertAll<string>(
delegate(string s)
{
return s.ToLower();
});

// ... and now print it out
haiku.ForEach(Console.WriteLine);
}
}

Or, the conversion could be removed and the ToLower() call could be moved to the last ForEach.

Solution #3:

using System;
using System.Collections.Generic;

class WWWTC
{
static void Main()
{
List<string> haiku = new List<string>();

haiku.Add("All software changes");
haiku.Add("Upon further reflection -");
haiku.Add("A reference to String");

// ... and now print it out
haiku.ForEach(
delegate(string s)
{
Console.WriteLine(s.ToLower());
});
}
}

And, there's the more declarative way of doing this which tends to work better when dealing with immutable data:

Solution #4a (in C# 2.0):

using System;
using System.Collections.Generic;

class WWWTC
{
static void Main()
{
List<string> haiku = new List<string>();

haiku.Add("All software changes");
haiku.Add("Upon further reflection -");
haiku.Add("A reference to String");

haiku.ConvertAll<string>(
delegate(string s)
{
return s.ToLower();
}
).ForEach(Console.WriteLine);
}
}

Solution #4b (in C# 3.0):

using System;
using System.Collections.Generic;

class WWWTC
{
static void Main()
{
List<string> haiku = new List<string>();

haiku.Add("All software changes");
haiku.Add("Upon further reflection -");
haiku.Add("A reference to String");

haiku.ConvertAll(s => s.ToLower()).ForEach(Console.WriteLine);
}
}

Another similar example is like this:

public class Person
{
public int Id;
}

public void ChangeIt(Person per)
{
per = new Person();
per.Id = 2;
}

Main method:
-------------------

Person p = new Person();
p.Id = 1;

ChangeIt(p);

What will be the Id of p at this time? It will be still 1.

Same thing happens to the parameter s in the blog post.