Question about inconsistent code generation while using "foreach" and "List<T>"

[marco-carvalho]

I have those methods:

static void ListForEach(List<int> numbers)
{
    foreach (int number in numbers)
    {
        Console.WriteLine(number);
    }
}

static void ListFor(List<int> numbers)
{
    for (int i = 0; i < numbers.Count; i++)
    {
        Console.WriteLine(numbers[i]);
    }
}

static void ArrayForEach(int[] numbers)
{
    foreach (int number in numbers)
    {
        Console.WriteLine(number);
    }
}

static void ArrayFor(int[] numbers)
{
    for (int i = 0; i < numbers.Length; i++)
    {
        Console.WriteLine(numbers[i]);
    }
}

They generate something like this:

[NullableContext(1)]
[CompilerGenerated]
internal static void <<Main>$>g__ListForEach|0_0(List<int> numbers)
{
    List<int>.Enumerator enumerator = numbers.GetEnumerator();
    try
    {
        while (enumerator.MoveNext())
        {
            Console.WriteLine(enumerator.Current);
        }
    }
    finally
    {
        ((IDisposable)enumerator).Dispose();
    }
}

[NullableContext(1)]
[CompilerGenerated]
internal static void <<Main>$>g__ListFor|0_1(List<int> numbers)
{
    int num = 0;
    while (num < numbers.Count)
    {
        Console.WriteLine(numbers[num]);
        num++;
    }
}

[NullableContext(1)]
[CompilerGenerated]
internal static void <<Main>$>g__ArrayForEach|0_2(int[] numbers)
{
    int num = 0;
    while (num < numbers.Length)
    {
        Console.WriteLine(numbers[num]);
        num++;
    }
}

[NullableContext(1)]
[CompilerGenerated]
internal static void <<Main>$>g__ArrayFor|0_3(int[] numbers)
{
    int num = 0;
    while (num < numbers.Length)
    {
        Console.WriteLine(numbers[num]);
        num++;
    }
}

https://sharplab.io/#v2:D4AQTAjAsAUCAMACEEAsBuWsUDZmsQBkBLAZwBcAxAewCcBRAQwGMALAChIoB5iA7cgD5EfAK4BbAEYBTWqQCUsAN6xEaxADM60lq0Tt+5ERJm1E/Y1NkLV6lTHWPkEAJzsxV2vMwP1AX1gAmGwIPBACLio6TjJyXgFhD1MbGHtHLTMDAXNEAF5EeHQc7ktkgDoAYWpRASLiAGp6xV81NKc1FDck6wBtYgBdb1s1IKCQsIIAQVpaRgBPGgZdLPIe/tLrZra1DJ02fUMNswtuuWbHbadO9xNZIZbEUaw4UPxEadmF6MM1o5TLjIHbLEPIFOqIEqnUhlQjSPgAc3IrDqjXOdmGV1cN08pD6gx8jieMCAA=

Why only foreach with List<T> generate a different final code?

[EgorBo]

foreach for List<T> generates exactly what it is supposed to do for foreach over IEnumerable, it's just Roslyn special cases Arrays to emit better (simpler to optimize) IL.

[KalleOlaviNiemitalo]

ListForEach uses List<T>.Enumerator.MoveNext(), which throws InvalidOperationException if the list has been modified after the enumerator was created.

ListFor and ArrayFor don't check that because they use just an integer index rather than a enumerator object.

ArrayForEach doesn't check that because arrays don't keep track of modifications.

[huoyaoyuan]

Here "modification" means changing the size of the containing list. Size of array can't be changed.

[KalleOlaviNiemitalo]

The List<T>.this[int index] setter increments _version and thus counts as a modification, even though it doesn't change the size of the list.

runtime/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs

Lines 155 to 163 in 10107d3

	set
	{
	if ((uint)index >= (uint)_size)
	{
	ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessException();
	}
	_items[index] = value;
	_version++;
	}