Conditional Foreach Performance Considerations in DotNet (C#)

When operating on large data sets in .Net, there is frequently a need to cancel the operations. We have already determined the steady-state performance considerations of basic loop structures, but adding a cancellation check may change that. As determined before, Arrays are generally the faster structure except when using .Net's MoveNext(). for loops are the fastest, followed closely by foreach.

This quick study hopes to see if there is any change in which to select based on the use of a cancellation token.
Let's try a few approaches to implementation that will demonstrate the differences:

/// <summary>
/// Runs a test of each Loop given a number of items
/// </summary>
/// <param name="numberOfItems">The number of items</param>
/// <returns>Returns an array of results</returns>
public static long[] Run(int numberOfItems)
{
	var ret = new long[6];
	var sw = new System.Diagnostics.Stopwatch();
	var testList = MakeTestList(numberOfItems);
	var token = default(CancellationToken);

	// for loop on List
	var current = 0;
	sw.Start();
	for (int i = 0; !token.IsCancellationRequested && i < numberOfItems; i++)
	{
		current += testList[i];
	}
	sw.Stop();
	ret[0] = sw.Elapsed.Ticks;

	// foreach loop on List
	current = 0;
	sw.Restart();
	foreach (var val in testList)
	{
		if (token.IsCancellationRequested) break;
		current += val;
	}
	sw.Stop();
	ret[1] = sw.Elapsed.Ticks;

	// enumerator MoveNext on List
	current = 0;
	sw.Restart();
	var enumerator = testList.GetEnumerator();
	while (!token.IsCancellationRequested && enumerator.MoveNext())
	{
		current += enumerator.Current;
	}
	sw.Stop();
	ret[2] = sw.Elapsed.Ticks;

	var testArray = MakeTestArray(numberOfItems);
	current = 0;
	// for loop on Array
	sw.Restart();
	for (int i = 0; !token.IsCancellationRequested && i < numberOfItems; i++)
	{
		current += testArray[i];
	}
	sw.Stop();
	ret[3] = sw.Elapsed.Ticks;

	current = 0;
	// foreach loop on Array
	sw.Restart();
	foreach (var val in testArray)
	{
		if (token.IsCancellationRequested) break;
		current += val;
	}
	sw.Stop();
	ret[4] = sw.Elapsed.Ticks;

	// enumerator MoveNext on Array
	current = 0;
	sw.Restart();
	var aenumerator = testArray.GetEnumerator();
	while (!token.IsCancellationRequested && aenumerator.MoveNext())
	{
		current += (int)aenumerator.Current;
	}
	sw.Stop();
	ret[5] = sw.Elapsed.Ticks;

	return ret;
}

Here is the average of 30 runs (all times in Ticks):

Average Time (in ticks) to access N number of items

Now, normalize the times to ticks per item.

Normalized Average Time (with respect to ticks / item)

Show the results on a log2 - log2 plot...

At first, we see that adding the cancellation check has also added ~20 nanoseconds (there are 100 nanoseconds / tick). As expected, for and foreach loops on Arrays are fastest. Using the enumerator's MoveNext() on the List is slower than calling foreach, but not by much - and this gap is narrower then when not checking for a cancellation. The enumerator with MoveNext() as it is always slower.

The Array enumerator is still the slowest.

In conclusion, adding a cancellation check does not change the selection of a loop type. It is still recommended to use for loops, then foreach loops, then enumerators MoveNext().