C# Var

Var keyword

Var is an implicit type. It aliases any type. The aliased type is determined by the C# compiler. This has no performance penalty. Var is excellent, and tasty, syntactic sugar: it makes programs shorter and easier to read.

Syntactic Sugar

Example

Framework: NET

First we look at some examples of the var keyword. Here is a code example of the var keyword being used in three contexts. Please note that you need a recent version of the .NET Framework to compile this program.

Based on:

.NET 4.5

Program that uses var keyword: C#

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public static void Main()
    {
	// 1.
	// var is always available, not just in Linq.
	var cat = new List<int>
	{
	    1,
	    2,
	    7,
	    9
	};
	// Hover over the 'var' keyword and Visual Studio
	// will tell you what it really is.

	// 2.
	// This example display odd numbers.
	// Returns IEnumerable<T> (where T is int).
	var items = from item in cat
		    where (item % 2 == 1)
		    select item;

	// 3.
	// Each item is an int.
	foreach (var item in items)
	{
	    Console.WriteLine(item);
	}
	// The previous loop is the same as this:
	foreach (int item in items)
	{
	    Console.WriteLine(item);
	}
    }
}

Output

1
7
9

1
7
9
List type

This code uses the var keyword and the List type. The variable is known to be a List. You can hover over the var keyword and Visual Studio tells you the type List. This feature is called IntelliSense.

Visual Studio

Next, we see the var items query. It returns IEnumerable<int>. The query expression is evaluated to this type—and var implicitly refers to that type. You can use var with the foreach-loop. You can use it like any other variable.

IEnumerable

Tip:The var keyword can represent any type that can be determined at compile-time. It is precisely equivalent after compilation.

Type systems

Squares

The C# language has a strong type system. This means that memory is labeled by what kind of object it contains. The language uses strong types to enforce code quality. Variables are both memory and also type annotations.

So:The C# compiler raises errors and warnings because it wants your code to work properly.

And:It makes inferences about your code and can deduce the type of a variable.

Compile-Time Error

Brevity of the language. The C# programming language is wordy. Programmers don't like entering text all day. Languages like C# and Java sometimes have lengthy keywords. You can reduce this with var—it's only three letters.

Limitations

Null keyword

Next, we consider some interesting limitations of the var keyword. You can't assign a var to null. This will result in the CS0825 warning. You also can't use var as a parameter type or a return value of a method.

NullReturn

Implementation

Collection abstraction: squares

Next, we look at the internal implementation and behavior of the var keyword. C# code is turned into IL. You can see it with a utility called IL Disassembler provided with Visual Studio. There are two int32 values in the IL below.

IL Disassembler

Note:The int declaration is the same as the var declaration in the IL. So the execution engine doesn't know that you used var.

And:They are compiled to the same IL. The var keyword is equally fast as explicit types like int or string.

Intermediate Language
Method using var: C#

public int ReturnValue()
{
    var a = 5;
    int b = 5;

    return a + b;
}

IL of the method

.method public hidebysig instance int32  ReturnValue() cil managed
{
  // Code size       9 (0x9)
  .maxstack  1
  .locals init ([0] int32 result,
	   [1] int32 CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldc.i4.5
  IL_0002:  stloc.0
  IL_0003:  ldloc.0
  IL_0004:  stloc.1
  IL_0005:  br.s       IL_0007
  IL_0007:  ldloc.1
  IL_0008:  ret
} // end of method VarKW::ReturnValue

Uses

Examples

One tip is to use var on generic types. The Dictionary type has verbose syntax—it uses a lot of brackets and letters and a comma. Some code becomes much easier to read with this keyword. Var can even make code refactoring easier.

Var Dictionary Example

Tip:If you change a type name with refactoring, a var type local will not need to be changed.

Next, you can use var in a foreach-loop construct. This makes the loop syntax simpler. Simple often means easy to understand. Simple often means fewer bugs will accumulate with time.

Foreach

Summary

The C# programming language

We used the var keyword in the C# language. You find out what it stands for by hovering over it in Visual Studio. It has similarities to #define or typedef in C++. We use var for brevity. It makes the code easier to understand.

And:The var keyword has equivalent performance. It has no effect on runtime behavior.


C#: Method