Tutorial C# Core : Variables

Compilation is a process by which the computer understands our English-like statements by its own processing mechanism. So, what is “bool”? Well, it is just like int, that is another kind of data type. Is bool the same as int? No, they are not. An int stores numbers and bool stores either Yes/No or True/False (no, Maybe is not allowed). Don't worry, C# has a rich set of various data types to handle all sorts of data. You will also notice the "//"; this is a special C# instruction to the compiler to basically ignore anything that follows the “//”. It is called comments, mostly used by coders to provide notes/remarks to emphasize the importance or anything else they feel about that specific statement. Mostly done in good faith by cool coders to help themself or someone else to understand what the heck this statement is doing! It is a safe and good practice to always initialize variables, well before we start using it in some part of any given process. If we fail to do so, the C# compiler will not like it and be mad at us, you know giving errors. This prevents us from unintentionally retrieving potential bad data values from the memory. So, if you don't want to see the error: Use of unassigned local variable 'age' than always remember to initialize your variables.

The "var" Keyword

Remember when we declare int age = 10; we basically told the compiler explicitly the variable is of integer type. Now, if we do the same declaration like : var age = 10; then we are letting the compiler determine the data type at run-time implicitly. In this case it is an integer, because it stores the data “10” which is a number with no digits. Not to be surprised here, the compiler basically treats both statements as the same. If you want to use the "var" keyword for declaration, the “Scope” of the variable becomes important, it is mostly local. We will see the scope soon. On an advanced side note, we cannot use the keyword "var" to declare field/property/parameter/return types (I hope to cover them soon in future articles).

Scope

Scope, commonly also referred to as visibility, is very important when we declare a variable. It is good to determine the visibility aspect before we declare a variable. Suppose we are coding a complex process and a specific variable is used in many different parts of it, then it makes sense to declare it as Public visibility. In the case of a variable that is only needed to be used during the life of any looping or any specific code block that starts and ends with curly braces {}, we can stick to Private visibility. Once we declare a variable public, we cannot declare the same variable name with private visibility. Take a look a the following scope example using a loop:
For the sake of simplicity of this beginner tutorial I am not covering the other available scopes: Protected, Friend and ProtectedFriend in this specific article. Once again, scoping helps us in the use of the variable within a code block, inside a method/function, class level or at the global project level.

Constant Variables

As the name suggests, we define a constant variable with a purpose to retain its value throughout its life cycle. Check out the following statement, all we need to do is add the keyword const in front of the data type and assign it a value:

const int maximum_runs = 100; // This value cannot be changed.

Do we store constants in our brain? I guess many of us do, only preferences change from one to another. What is your favorite constant anyway? I told you mine already, the lucky number 7. Do share some of yours, I hear one: super_hero = “Spider Man”, is it? Constants generally make the code easier to read and modify. For example, if you define a constant called Max_Age_Limit and initialize it to 60, now down the road if you want to change this to reflect 65 instead, all you need to do is change it in one place and it affects all the places where Max_Age_Limit is used for any purpose.

As we progress toward more advanced aspects of C#, we will need to deal with some other forms of variables such as: value types of variables, like enum and reference types of variables like class and static variables, that I will hope to cover in some future article.

C# includes support for the following built-in data types:

Data Type	Range
byte	0 .. 255
sbyte	-128 .. 127
short	-32,768 .. 32,767
ushort	0 .. 65,535
int	-2,147,483,648 .. 2,147,483,647
uint	0 .. 4,294,967,295
long	-9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
ulong	0 .. 18,446,744,073,709,551,615
float	-3.402823e38 .. 3.402823e38
double	-1.79769313486232e308 .. 1.79769313486232e308
decimal	-79228162514264337593543950335 .. 79228162514264337593543950335
char	A Unicode character.
string	A string of Unicode characters.
bool	True or False.
object	An object.

Here is an example of variables in action using a console application:

Assuming your demo code compiles and runs, you will see the following output on the console screen: x = 10, y = 50, z = 60

In my next installment in this series I will write about various usage scenarios of data types and some more related goodies. I'm always looking forward to any constructive criticism and who doesn't like little praise eh! I hope the content provided you with some good insight about one of the core features of C# and you also enjoyed it.