I’ve set up a set of tests to check performance between the foreach using var vs. cast with the LINQ query in the foreach vs. done separately. Essentially I added 10000 elements to a list with the property to get the element number pausing for 1ms. The LINQ statement returns items MOD 5 (returning 2005 items)
I ran the tests in different orders several times and the results were virtually identical within a 2% variance. The curious thing was that performing the query outside of the foreach was typically that 2% slower than both tests with the LINQ performed in the foreach. There was no difference between using var vs. explicit type specification within the foreach.

Steve Py :
Yes, the Lambda rule would be evaluated each iteration in that example.

Um…no.

void Main()
{
var list = new[] { new Animal{Name = “Bulldog”}, new Animal{Name = “Leopard”}, new Animal{Name = “Doberman”} };

foreach (var data in list.Where(x => x.IsDog))
{
Console.WriteLine(data.ToString());
}

}

class Animal
{
public string Name { get; set; }
public bool IsDog
{
get
{
Console.WriteLine(“IsDog called”);
return Name != “Leopard”;
}
}
public override string ToString() { return Name; }
}

Output:

IsDog called
Bulldog
IsDog called
IsDog called
Doberman

foreach (Dog dog in animalList.OfType<Dog>())

Curse this angle-bracket HTML/generics confusion!