This is of course by no means a conclusive result, but should be fairly indicative of the truth… the plan was to compare different ways of iterating through a collection (List) of items:

Code:

public static bool ForEach( List items ) {
	foreach( TestObject item in items ) {
		if( string.Compare(__SearchString, item.TestString, true) == 0 ) {
			return true;
		}
	}
	return false;
}

public static bool ForLoop( List items ) {
	for( int n = 0; n < items.Count; n++ ) {
		if( string.Compare(__SearchString, items[n].TestString, true) == 0 ) {
			return true;
		}
	}
	return false;
}

public static bool ListFindDelegate( List items ) {
	return null != items.Find(delegate( TestObject item ) {
		return ((string.Compare(__SearchString, item.TestString, true) == 0));
	});
}

public static bool ListFindLambda( List items ) {
	return null != items.Find(item =>
		string.Compare(__SearchString, item.TestString, true) == 0);
}

public static bool LinqSingleOrDefault( List items ) {
	return null != items.SingleOrDefault(item =>
		string.Compare(__SearchString, item.TestString, true) == 0);
}

public static bool LinqFirstOrDefault( List items ) {
	return null != items.FirstOrDefault(item =>
		string.Compare(__SearchString, item.TestString, true) == 0);
}

List for “Small” test contains 10,000 items, while “Big” lists have 100,000 items. The test is repeated 1,000 times for each, and the result shows the average time taken to go through the list (including the string compare on each item, which is implemented identically on every test):

Output:

Results:
ForEach
        Small: 1.0907135
        Big: 10.6290456
ForLoop
        Small: 1.0595758
        Big: 10.2840301
ListFindDelegate
        Small: 1.0659918
        Big: 10.4202481
ListFindLambda
        Small: 1.0765722
        Big: 10.4956308
LinqSingleOrDefault
        Small: 1.5023778
        Big: 14.7892056
LinqFirstOrDefault
        Small: 1.5661344
        Big: 15.4384855

Conclusion:

If you’re interested to run it on your own machine, you can grab the source code here.