faster way between to ways of iterating through all the elements of a collection in C#

Question

The language I use is C#.

Let we have a List of objects of type T,

List<T> collection = new List<T>{.....};

Say that we want to go over each item of collection. That can be done in many ways. Among of them, are the following two:

foreach(var item in collection)
{
   // code goes here
}

and

foreach(T item in collection)
{
    // code goes here
}

Does the second way be better than the first or not and why?

Thanks in advance for your answers.

Answer 1

They're both exactly the same. var is syntactic sugar for convenience. It makes no difference to the speed with which a List is traversed.

The rule of thumb I follow with var is to only use it if the type of the object is present on the right-hand side of an assignment, so in this case I'd prefer to explicitly specify the type in the foreach to make it clearer for other engineers, but it's down to personal choice. If you hover over a var in Visual Studio, it will display the type (assuming it can infer what is should be).

Answer 2

Quoting MSDN:

An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type.

So

var i = 10; // implicitly typed
int i = 10; //explicitly typed

Are exactly the same.

Now, for 'better' - It'll heavily depend on what's your parameter to judge that. If it's speed, then a for loop may be better than a foreach, and T[] better than List<T>, according to Patrick Smacchia. Main points:

• for loops on List are a bit more than 2 times cheaper than foreach loops on List.
• Looping on array is around 2 times cheaper than looping on List.
• As a consequence, looping on array using for is 5 times cheaper than looping on List using foreach (which I believe, is what we all do).

Quote source: In .NET, which loop runs faster, 'for' or 'foreach'?

Reference: http://msdn.microsoft.com/en-us/library/bb383973.aspx

Answer 3

If you compare the IL code then you will see that the are really 100% the same. var is only syntactic sugar:

C# Code:

  List<int> collection = new List<int>();
  collection.Add(1);
  collection.Add(2);
  collection.Add(3);

  foreach (var myInt in collection)
  {
    Console.WriteLine(myInt);
  }

  foreach (var T in collection)
  {
    Console.WriteLine(T);
  }

---

 bool flag;

            System.Collections.Generic.List<int> list = new System.Collections.Generic.List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            System.Collections.Generic.List<int>.Enumerator enumerator = list.GetEnumerator();
            try
            {
                while (flag)
                {
                    int i1 = enumerator.get_Current();
                    System.Console.WriteLine(i1);
                    flag = enumerator.MoveNext();
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            enumerator = list.GetEnumerator();
            try
            {
                while (flag)
                {
                    int i2 = enumerator.get_Current();
                    System.Console.WriteLine(i2);
                    flag = enumerator.MoveNext();
                }
            }
            finally
            {
                enumerator.Dispose();
            }

Answer 4

There is no faster way to iterate through same collection.

No matter what you use, your own loop or extension methods - this is all the same. When you use var - it still compiles to the same thing.

The only difference might be that if you use Dictionary, it will be faster than the List<T> or Collection in terms of searching for values. Dictionary was designed with optimization for search

Answer 5

1st way (with var) might be better for readability. Consider this:

List<User> list = new List<User>();
var users = list.GroupBy(x => x.Name).OrderBy(x => x.Key);
foreach (var user in users)
{
 //blah
}

vs

foreach (System.Linq.IGrouping<string, User> user in users)
{
}

I believe that was the main reason for having var in the first place.