Is It Faster to Enumerate an Array With "foreach" or "for" in C#?
Tags: csharp, performance
Published: 2022-12-22 10:10:47

---
title: Is It Faster to Enumerate an Array With "foreach" or "for" in C#?
published: true
description: 
tags: ["csharp", "performance"]
canonical_url: https://www.aloneguid.uk/posts/2022/12/is-it-faster-to-enumerate-an-array-with-foreach-or-for-in-csharp/
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2022-12-22 10:08 +0000
---

Here's an interesting question - having an array of integers, is it faster to enumerate it, to perform a simple operation on an element, with `for` or `foreach`?

To answer this, first of all I've created a benchmark that covers 3 use cases:

1. Use `for` loop and get an element by it's index.
2. Use `foreach` on the array.
3. Use `foreach` on the array, but before enumerating case the array to `IEnumerable` forcibly. I don't know why I had a hunch that might behave slightly different, but I did it anyway.

Here is the testing code:

```csharp
#LINQPad optimize+

void Main()
{
	Util.AutoScrollResults = true;
	BenchmarkRunner.Run<Enumeration>();
}

[ShortRunJob]
[MinColumn, MaxColumn, MeanColumn, MedianColumn]
[MemoryDiagnoser]
[MarkdownExporter]
public class Enumeration
{
    int[] _source;
    
	[Params(10, 100, 1000, 10000, 100000)]
	public int Length;


	[GlobalSetup]
	public void Setup()
	{
		_source = Enumerable.Range(0, Length).ToArray();
	}


	[Benchmark]
	public void EnumerateAsArray()
	{
        int count = 0;
        for(int i = 0; i < Length; i++) {
            int element = _source[i];
            count += 1;
        }
	}

	[Benchmark]
	public void EnumerateWithForeach()
	{
        int count = 0;
        foreach(int i in _source) {
            count += 1;
        }
	}

    [Benchmark]
    public void EnumerateWithForeachAfterCasting() {
        int count = 0;
        foreach (int i in (IEnumerable)_source) {
            count += 1;
        }
    }
}
```

And the result:


|                           Method | Length |             Mean |             Error |          StdDev |              Min |              Max |           Median |     Gen0 | Allocated |
|--------------------------------- |------- |-----------------:|------------------:|----------------:|-----------------:|-----------------:|-----------------:|---------:|----------:|
|                 EnumerateAsArray |     10 |         3.473 ns |         1.4879 ns |       0.0816 ns |         3.385 ns |         3.546 ns |         3.490 ns |        - |         - |
|             EnumerateWithForeach |     10 |         3.081 ns |         0.6979 ns |       0.0383 ns |         3.057 ns |         3.125 ns |         3.062 ns |        - |         - |
| EnumerateWithForeachAfterCasting |     10 |       360.151 ns |       112.8064 ns |       6.1833 ns |       353.018 ns |       363.983 ns |       363.452 ns |   0.0648 |     272 B |
|                 EnumerateAsArray |    100 |        49.681 ns |        10.2353 ns |       0.5610 ns |        49.237 ns |        50.311 ns |        49.495 ns |        - |         - |
|             EnumerateWithForeach |    100 |        42.489 ns |        15.0294 ns |       0.8238 ns |        41.728 ns |        43.364 ns |        42.375 ns |        - |         - |
| EnumerateWithForeachAfterCasting |    100 |     3,365.735 ns |     1,017.7344 ns |      55.7855 ns |     3,330.609 ns |     3,430.059 ns |     3,336.535 ns |   0.5798 |    2432 B |
|                 EnumerateAsArray |   1000 |       404.754 ns |       101.6160 ns |       5.5699 ns |       399.244 ns |       410.382 ns |       404.638 ns |        - |         - |
|             EnumerateWithForeach |   1000 |       366.522 ns |        44.1604 ns |       2.4206 ns |       364.396 ns |       369.157 ns |       366.015 ns |        - |         - |
| EnumerateWithForeachAfterCasting |   1000 |    34,436.210 ns |    16,553.4298 ns |     907.3493 ns |    33,513.147 ns |    35,326.984 ns |    34,468.500 ns |   5.7373 |   24032 B |
|                 EnumerateAsArray |  10000 |     4,011.964 ns |     1,402.6901 ns |      76.8862 ns |     3,924.527 ns |     4,069.007 ns |     4,042.358 ns |        - |         - |
|             EnumerateWithForeach |  10000 |     3,644.260 ns |       350.8573 ns |      19.2317 ns |     3,632.706 ns |     3,666.461 ns |     3,633.613 ns |        - |         - |
| EnumerateWithForeachAfterCasting |  10000 |   340,725.798 ns |   170,058.5539 ns |   9,321.4832 ns |   330,179.199 ns |   347,861.084 ns |   344,137.109 ns |  57.1289 |  240033 B |
|                 EnumerateAsArray | 100000 |    40,460.423 ns |     9,494.4089 ns |     520.4206 ns |    40,090.979 ns |    41,055.597 ns |    40,234.692 ns |        - |         - |
|             EnumerateWithForeach | 100000 |    36,107.100 ns |     6,022.3198 ns |     330.1037 ns |    35,901.172 ns |    36,487.848 ns |    35,932.281 ns |        - |         - |
| EnumerateWithForeachAfterCasting | 100000 | 3,892,458.333 ns | 4,019,109.7373 ns | 220,300.9666 ns | 3,652,532.422 ns | 4,085,627.734 ns | 3,939,214.844 ns | 570.3125 | 2400038 B |

The findings are impressive - enumerating an **array** with `for` or `foreach` is not much different, but surprisingly `foreach` is slightly faster (around 12%). Whereas when casting to `IEnumerable` and then performing iteration is way way slower than anything else! In fact, it's about 107 times slower than normal array iteration!

To understand what's happening, I'm going to disassembly the generated code.

## EnumerateAsArray

This is IL representation:

```
IL_0000  ldc.i4.0   
IL_0001  stloc.0     // count 
IL_0002  ldc.i4.0   
IL_0003  stloc.1     // i 
IL_0004  br.s  IL_0017 
IL_0006  ldarg.0   
IL_0007  ldfld  Enumeration._source 
IL_000C  ldloc.1     // i 
IL_000D  ldelem.i4   
IL_000E  pop   
IL_000F  ldloc.0     // count 
IL_0010  ldc.i4.1   
IL_0011  add   
IL_0012  stloc.0     // count 
IL_0013  ldloc.1     // i 
IL_0014  ldc.i4.1   
IL_0015  add   
IL_0016  stloc.1     // i 
IL_0017  ldloc.1     // i 
IL_0018  ldarg.0   
IL_0019  ldfld  Enumeration.Length 
IL_001E  blt.s  IL_0006 
IL_0020  ret  
```

As you can see, this is what's happening:

1. Create two variables - `count` and `i`.
2. Keep comparing array length to `i` (IL_0017). When `i` is less than array length, jump to IL_0006.
3. Load array element.
4. Increment the count.
5. Increment `i`.

Simple enough.

## EnumerateWithForeach

IL source:

```
IL_0000  ldc.i4.0   
IL_0001  stloc.0     // count 
IL_0002  ldarg.0   
IL_0003  ldfld  Enumeration._source 
IL_0008  stloc.1   
IL_0009  ldc.i4.0   
IL_000A  stloc.2   
IL_000B  br.s  IL_0019 
IL_000D  ldloc.1   
IL_000E  ldloc.2   
IL_000F  ldelem.i4   
IL_0010  pop   
IL_0011  ldloc.0     // count 
IL_0012  ldc.i4.1   
IL_0013  add   
IL_0014  stloc.0     // count 
IL_0015  ldloc.2   
IL_0016  ldc.i4.1   
IL_0017  add   
IL_0018  stloc.2   
IL_0019  ldloc.2   
IL_001A  ldloc.1   
IL_001B  ldlen   
IL_001C  conv.i4   
IL_001D  blt.s  IL_000D 
IL_001F  ret  
```

It's not much different to before, but .NET runtime makes slight optimisation, because it knows you are going to need to value and not need the index (`foreach` always retrieves the value). So that's good!

## EnumerateWithForeachAfterCasting

IL source:

```
IL_0000  ldc.i4.0   
IL_0001  stloc.0     // count 
IL_0002  ldarg.0   
IL_0003  ldfld  Enumeration._source 
IL_0008  callvirt  IEnumerable.GetEnumerator () 
IL_000D  stloc.1   
IL_000E  br.s  IL_0020 
IL_0010  ldloc.1   
IL_0011  callvirt  IEnumerator.get_Current () 
IL_0016  unbox.any  Int32 
IL_001B  pop   
IL_001C  ldloc.0     // count 
IL_001D  ldc.i4.1   
IL_001E  add   
IL_001F  stloc.0     // count 
IL_0020  ldloc.1   
IL_0021  callvirt  IEnumerator.MoveNext () 
IL_0026  brtrue.s  IL_0010 
IL_0028  leave.s  IL_003B 
IL_002A  ldloc.1   
IL_002B  isinst  IDisposable 
IL_0030  stloc.2   
IL_0031  ldloc.2   
IL_0032  brfalse.s  IL_003A 
IL_0034  ldloc.2   
IL_0035  callvirt  IDisposable.Dispose () 
IL_003A  endfinally   
IL_003B  ret  

```

Wow! You don't need to be an IL expect to see this will be slow, because it's full of `callvirt` calls. Calling virtual methods is expensive! This time **you** are forcing C# to use `IEnumerable` pattern, and that's exactly what it does. To represent this code in C# 1, it translates to the following:

```c#
int count = 0;
IEnumerator enumerator = ((IEnumerable)_source).GetEnumerator ();
try
{
    while (enumerator.MoveNext ())
    {
        int num = (int)enumerator.Current;
        count++;
    }
}
finally
{
    IDisposable disposable = enumerator as IDisposable;
    if (disposable != null)
    {
        disposable.Dispose ();
    }
}
```

So a lot of method calls and unboxing, all are extremely expensive.

![](https://www.aloneguid.uk/posts/2022/12/is-it-faster-to-enumerate-an-array-with-foreach-or-for-in-csharp/il.png)

## Summary

1. If you can, prefer `foreach` to `for` loops, they will be slightly faster.
2. Never cast arrays to `IEnumerable` and then enumerate, as this expands into a lot of virtual calls using `IEnumerator` pattern.