C# 3.0 var keyword
Software Development September 15th, 2007
C# 3.0 has many-a-new features. This post will explain the ’var’ keywork and the concept of Implicitly Typed Variables.
The var keyword is not a late-bound or un-typed variable reference. The var keyword always generates a strongly typed variable reference. The main idea is that the developer is not required to define the type of the variable at the time of declaration, but it is the task of the compiler to decide what type of the object the variable is. The compiler infer the type of the variable from the expression used to initialize the variable when it is first declared.
Important points about var keyword:
- The type of the variable is defined by the value declared and decided at the compile time. (Size depends on the type of the value initialised)
- Type casting is simple and handled by CLR.
- Explicit functions for parsing to specific type.
- Can be used to reference any type in C#.
- The CLR actually never knows that the var keyword is being used.
What rules shuold you force to use the var keyword?
When you declare variable with the var keyword, you must to always do an initial value assignment. This is because the var keyword produces a strongly-typed variable declaration. Hence, the compiler needs to be able to infer the type to declare based on its usage. If you don’t, the compiler will produce a compiler error.
1: var vAge = 32;
2: var vHeight = 175.2;
3: var vName = “Maor David“;
The compiler will infer the type of the “age”, “height” and “name” variables based on the type of their initial assignment value. This means it will generate IL that is absolutely identical to the code below:
1: int age = 32;
2: double height = 175.2;
3: string name = "Maor David";
You can also use it to other data types:
1: foreach (var vTable in ds.Tables)
2: {
3: foreach (var vRow in ((DataTable) vTable).Rows)
4: {
5:
6: }
7: }
This is equal to:
1: foreach (DataTable table in ds.Tables)
2: {
3: foreach (DataRow vRow in table.Rows)
4: {
5: }
6: }
You can read this post also at Maor David’s Blog: http://blogs.microsoft.co.il/blogs/maordavid/archive/2007/09/15/C_2300_-3.0-var-keyword.aspx
Similar Posts:
- C# 3.0 Extension Methods
- Query types using LINQ
- DebuggerDisplay Attribute
- Save datagrid changes in the database
- C# Automatic Properties
About
Wow… Is this the most useless syntactic sugar I have ever seen, or what? Who in their sane mind thought that this would be a good idea? You might as well declare all your variables as objects and box and un-box them everywhere (ps. I do realize it’s not exactly the same thing, I’m just speaking towards code readability).
This comment originally written by:
C# 3.0 has many-a-new features. This post will explain the ‘var’ keywork and the concept of Implicitly Typed Variables. The var keyword is not a late-bound or un-typed variable reference. The var keyword always generates a strongly typed variable reference
This comment originally written by:Maor David-Pur
NO….var keyword is great for using with Linq.
Also, there are two cases where "var" is very useful. The first: is with complicated generic types. The second: var is useful is with anonymous types. Since you can’t name these types, you need to use var when you want to assign values of these anonymous types to local variables.
This comment originally written by:Marv
So the main benefit is for lazy programmers?
This comment originally written by:Maor David’s Blog
LINQ to XML is a built-in LINQ data provider that is implemented within the System.Xml.Linq namespace
This comment originally written by:Maor David – The Blog
How many times have you written wrapper methods for objects that in reality you wished were part of the
This comment originally written by:DrorEngel
this example
1: var vAge = 32;
2: var vHeight = 175.2;
3: var vName = “Maor David“;
is nice but very risky and have a vast impact of the application performance
not always the compiler will guess which type I want…
second, the type casting is not "cheap" in CLR time