int i = 5;
string s = "Hello C#";
double d = 1.0;
You’re allowed to offload some of that work onto the C# compiler, using the var
keyword:
<strong>var</strong> i = 5;
<strong>var</strong> s = "Hello C# 4.0";
<strong>var</strong> d = 1.0;
Now the compiler infers the data type for you — it looks at the stuff on the right side of the assignment to see what type the left side is.
For what it’s worth, there is a way to calculate the type of an expression like the ones on the right side of the assignments in the preceding example. Not that you need to do that — the compiler mostly does it for you. Suppose, for example, you have an initializing expression like this:
var x = 3.0 + 2 - 1.5;
The compiler can figure out that x
is a double
value. It looks at 3.0
and 1.5
and sees that they’re of type double
. Then it notices that 2
is an int
, which the compiler can convert implicitly to a double
for the calculation. All the additional terms in x
’s initialization expression end up as double
types. So the inferred type of x
is double
.
But now, you can simply utter the magic word var
and supply an initialization expression, and the compiler does the rest:
var aVariable = <initialization expression here>;
If you’ve worked with a scripting language such as JavaScript or VBScript, you may have gotten used to all-purpose-in-one data types. VBScript calls them Variant
data types — and a Variant
can be anything at all. But does var
in C# signify a Variant
type? Not at all. The object you declare with var
definitely has a C# data type, such as int
, string
, or double
. You just don’t have to declare what it is.
var
? Take a look at this:var aString = "Hello C# 3.0";
Console.WriteLine(aString.GetType().ToString());
The mumbo jumbo in that WriteLine
statement calls the String.GetType()
method on aString
to get its C# type. Then it calls the resulting object’s ToString()
method to display the object’s type. Here’s what you see in the console window:
System.String
The output from this code proves that the compiler correctly inferred the type of aString
.
Most of the time, the best practice is to not use var
. Save it for when it’s necessary. Being explicit about the type of a variable is clearer to anyone reading your code than using var
.
You can see var
used in other ways: with arrays and collections of data, and with anonymous types. Anonymous? Bet you can’t wait.
var:
The dynamic
type takes var
a step further.The var
type causes the compiler to infer the type of the variable based on expected input. The dynamic
keyword does this at runtime, using a set of tools called the Dynamic Language Runtime.