JacksonDunstan.com

public struct ArrayIterator<T>
{
	public T[] Array;
	public int Index;
}

public static class ArrayIteratorExtensions
{
	public static ArrayIterator<T> Begin<T>(this T[] array)
	{
		return new ArrayIterator<T> { Array = array };
	}
 
	public static ArrayIterator<T> End<T>(this T[] array)
	{
		return new ArrayIterator<T> { Array = array, Index = array.Length };
	}
 
	public static ArrayIterator<T> IteratorAt<T>(this T[] array, int index)
	{
		return new ArrayIterator<T> { Array = array, Index = index };
	}
 
	public static T GetCurrent<T>(this ArrayIterator<T> it)
	{
		return it.Array[it.Index];
	}
 
	public static ArrayIterator<T> GetNext<T>(this ArrayIterator<T> it)
	{
		it.Index++;
		return it;
	}
 
	public static ArrayIterator<T> GetPrev<T>(this ArrayIterator<T> it)
	{
		it.Index--;
		return it;
	}
 
	public static bool IsEqual<T>(this ArrayIterator<T> it, ArrayIterator<T> other)
	{
		return it.Array == other.Array && it.Index == other.Index;
	}
 
	public static bool NotEqual<T>(this ArrayIterator<T> it, ArrayIterator<T> other)
	{
		return it.Array != other.Array || it.Index != other.Index;
	}
}

int FindMax(int[] array)
{
	var max = int.MinValue;
	for (
		// Get iterators for the beginning and end
		// Note: end is one past the last element
		ArrayIterator<int> it = array.Begin(), end = array.End();
		// Loop until the current iterator equals the end iterator
		it.NotEqual(end);
		// Move the current iterator forward
		it = it.GetNext()
	)
	{
		// Get the current iterator's current value
		var cur = it.GetCurrent();
		if (cur > max)
		{
			max = cur;
		}
	}
	return max;
}

public struct ListIterator<T>
{
	public IList<T> List;
	public int Index;
}
 
public static class ListIteratorExtensions
{
	public static ListIterator<T> Begin<T>(this IList<T> List)
	{
		return new ListIterator<T> { List = List };
	}
 
	public static ListIterator<T> End<T>(this IList<T> List)
	{
		return new ListIterator<T> { List = List, Index = List.Count };
	}
 
	public static ListIterator<T> IteratorAt<T>(this IList<T> List, int index)
	{
		return new ListIterator<T> { List = List, Index = index };
	}
 
	public static T GetCurrent<T>(this ListIterator<T> it)
	{
		return it.List[it.Index];
	}
 
	public static ListIterator<T> GetNext<T>(this ListIterator<T> it)
	{
		it.Index++;
		return it;
	}
 
	public static ListIterator<T> GetPrev<T>(this ListIterator<T> it)
	{
		it.Index--;
		return it;
	}
 
	public static bool IsEqual<T>(this ListIterator<T> it, ListIterator<T> other)
	{
		return it.List == other.List && it.Index == other.Index;
	}
 
	public static bool NotEqual<T>(this ListIterator<T> it, ListIterator<T> other)
	{
		return it.List != other.List || it.Index != other.Index;
	}
}

int FindMax(IList<int> list)
{
	var max = int.MinValue;
	for (
		ListIterator<int> it = list.Begin(), end = list.End();
		it.NotEqual(end);
		it = it.GetNext()
	)
	{
		var cur = it.GetCurrent();
		if (cur > max)
		{
			max = cur;
		}
	}
	return max;
}

using System;
using System.Collections.Generic;
using UnityEngine;
 
public class TestScript : MonoBehaviour
{
	private const int NumIterations = 100000;
 
	private class Counter
	{
		public int Value;
	}
 
	private string report;
 
	void Start()
	{
		report = string.Join(
			",",
			new[]{
				"Size",
				"Array For",
				"Array While",
				"Array Foreach",
				"Array Iterator",
				"List For",
				"List While",
				"List Foreach",
				"List Iterator"
			}
		) + "\n";
		var sizes = new []{ 10,100,1000 };
		foreach (var size in sizes)
		{
			report += Test(size);
		}
	}
 
	private string Test(int size)
	{
		var stopwatch = new System.Diagnostics.Stopwatch();
		var sum = 0;
		var array = new Counter[size];
		for (int i = 0; i < size; ++i)
		{
			array[i] = new Counter() { Value = i };
		}
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			for (int i = 0, len = array.Length; i < len; ++i)
			{
				sum += array[i].Value;
			}
		}
		var arrayForTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			var i = 0;
			var len = array.Length;
			while (i < len)
			{
				sum += array[i].Value;
				++i;
			}
		}
		var arrayWhileTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			foreach (var cur in array)
			{
				sum += cur.Value;
			}
		}
		var arrayForeachTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			for (
				ArrayIterator<Counter> it = array.Begin(), end = array.End();
				it.NotEqual(end);
				it = it.GetNext()
			)
			{
				sum += it.GetCurrent().Value;
			}
		}
		var arrayIteratorTime = stopwatch.ElapsedMilliseconds;
 
		var list = new List<Counter>(size);
		list.AddRange(array);
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			for (int i = 0, len = list.Count; i < len; ++i)
			{
				sum += list[i].Value;
			}
		}
		var listForTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			var i = 0;
			var len = list.Count;
			while (i < len)
			{
				sum += list[i].Value;
				++i;
			}
		}
		var listWhileTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			foreach (var cur in list)
			{
				sum += cur.Value;
			}
		}
		var listForeachTime = stopwatch.ElapsedMilliseconds;
 
		stopwatch.Reset();
		stopwatch.Start();
		for (var iteration = 0; iteration < NumIterations; ++iteration)
		{
			for (
				ListIterator<Counter> it = list.Begin(), end = list.End();
				it.NotEqual(end);
				it = it.GetNext()
			)
			{
				sum += it.GetCurrent().Value;
			}
		}
		var listIteratorTime = stopwatch.ElapsedMilliseconds;
 
		return size + ","
			+ arrayForTime + ","
			+ arrayWhileTime + ","
			+ arrayForeachTime + ","
			+ arrayIteratorTime + ","
			+ listForTime + ","
			+ listWhileTime + ","
			+ listForeachTime + ","
			+ listIteratorTime + "\n";
	}
 
	void OnGUI()
	{
		GUI.TextArea(new Rect(0, 0, Screen.width, Screen.height), report);
	}
}