This lesson will talk about implicitly typed local variables using the var keyword. The term “local” refers to variables declared within a method scope, or narrower, that are not available at a class level. And “implicitly typed” means the compiler can determine what the data type of the variable is based on context, and set it appropriately. You can let the compiler interpret the type by using the var keyword in place of the actual type declaration.
This works because the compiler references the actual type when compiling to Intermediate Language (IL). You can see that IntelliSense has no trouble understanding that this is supposed to be an int since it was already initialized to an integer value:
This extends beyond simple value types and works with objects as well:
There are a few caveats when dealing with implicitly typed variables:
You must initialize the variable with an assigned value type or object reference.
It is still type-strict. It takes on the implied data type, and cannot be changed any more than any other explicitly typed variable.
You may be wondering about the benefit of having implicitly typed variables since the var keyword adheres to the same strongly typed guidelines, and just obscures what should otherwise be obvious when you look at code at a glance. You will begin to see the benefits later on where, in some cases, it’s difficult to determine the data type ahead of time, the data type is unknown, or the data type becomes generated automatically at runtime. Just keep its function in mind as you will often see it being used in code examples provided on the internet. And, eventually, you will come across a case in which it is necessary.
To see how an implicitly typed variable can be used in code, make us of the following example. We're going to create a mock application in which we present the user with a group of RadioButtons to select from. Depending on their selection, we will display which data type was chosen, either String, Integer or Bool.
In your CS-ASP_051 Project, add a Default.aspx page, and add the following Server Controls:
Give these Server Controls the following ID's:
Set the GroupName property for the RadioButtons to myGroup.
Next, double-click the okButton generate the okButton_Click EventHandler. We'll deal with the code that goes in here later. For now, create a new public method called determineUserInput() that returns an object:
You may notice that this method is returning an Object rather than a string, int, or bool as we've used previously. The reason for this is that this method needs to return one of these based on what the user selects, so it needs the ability to be set to any of them. Because an Object can store the value of any of these variables, that is what we will return from this method.
Inside this method, declare three variables: One for string, bool and int:
In addition, create an Object called myObject, but do not set its value yet. Next, create a series of conditional statements that determine which RadioButton was selected. Depending on the RadioButton, set myObject equal to the appropriate value:
The purpose of this code is to assign myObject either the value of string, int or bool, then return it to the caller, which we will now create.
In the okButton_Click, create an implicitly typed variable called userInput and set it equal to the value of determineUserInput():
Now, our variable will take on the value of whatever the user has passed in, which at this point is unknown until runtime. In order to display this, we'll set the resultLabel to the following:
The particulars of how this code functions isn't important right now, but in essence, this uses a method to retrieve the type, not value, of the userInput variable. Then, we display it in the resultLabel. Save and run your project to see the result:
While convoluted and impractical, hopefully this example gives you an idea of the use of implicitly typed variables when dealing with unknown data types. Even though the user could select one of multiple data types (or even type, depending on the application), you are able to store their selection without having to create several different variables in your code.
Lesson 51 - Implicitly-Typed Variables with the var Keyword