C# - About variables

Variables

A Variable is a named location that stores a value. Although variables are physically stored in the RAM, their actual memory address is not known to the programmer. We can use the variables via the name we give them. These are the rules for naming a variable:-

* The name must begin with a letter or an underscore & can be followed by a sequence of letters (A-Z), digits (0-9) or underscore (_)
* Special Characters such as ? - + * / \ ! @ # $ % ^ ( ) [ ] { } , ; : . cannot be used in the variable name.
* A variable name must not be the same as a reserved keyword such as using, public, etc.
* The name can contain any number of the allowed characters
* Variables with the same scope cannot have the same name

Note: C# being a case-sensitive language, two variables such as var1 and Var1 would be different.

Any Variable has a type associated with it, which basically restricts the type of value it can store. The table below shows the Data types available in C#, the size they occupy in the memory and the values they can contain.

Variable Declaration
Before we can use a variable, we need to declare it. Declaration of variables are done using the syntax:-
;

For Example:-
CODE
int Age;
char Sex;
string Name;
bool IsMarried;

Variables of the same data type can also be declared using the syntax:-
,, .. and so on;

Example:-
CODE
int Age, RollNum;

Initialization
While declaring a variable, it is possible to assign an initial value to it. This operation is called Initialization and it has the following syntax:-
= ;

Example:-
CODE
int Age = 20;
char Sex = 'M';
string Name = 'Max Steel';
bool IsMarried = false;

Multiple variables of the same data type can also be initialized in a single line of code using the syntax:-
= , = ;

CODE
int Age = 20, RollNum = 69;

Value Types
Values can be stored in variables by two methods which are: by value and by reference. Value types store the supplied value directly in the memory whereas reference types store a reference to the memory where the actual value is located. The benefit of the reference type is that changes made to any alias of the variable will reflect across all of its aliases.

Accepting Values in Variables
To input values from the user at runtime, we use the Console.ReadLine() function. For Example:- string FirstName = Console.ReadLine(); The above statement would declare a string variable FirstName and store the value retrieved from the user in it.

Note: Console.ReadLine() returns value as a string. Therefore, one must use type casting to convert the value to the required type. We use the member functions of the Convert class to do this. For Example: int Age = Convert.ToInt32(Console.ReadLine());. Similarly, there are other functions such as ToChar(), ToString, etc for conversion to other data types.

Operators

Similar to mathematics, every programming language has its own set of operators, be it arithmetic or logical. Operators enable us to perform operations on 1 or more values (operands) and calculate the result.

Usage
Depending on the number of operands they take, operators can be either unary or binary.
The use of an operator takes one of the following form:-

Binary Usage

*

Unary Usage

*
*

Classification

The operators in C# can be classified as follows:-

Arithmetic operators - Just what the name suggests, these operators are used to perform arithmetic operations.

Arithmetic Assignment Operators - These can be considered as shortcuts as they are used to perform both arithmetic and assignment operations in a single step.

Increment / Decrement Operators - These operators are used to increment or decrement the value of an operand by 1.

Difference between Pre & Post Increment/Decrement
Consider the following code snippet:-

CODE
int A = 0;
int B = A++;
int C = ++A;

At the very first line, we have used the Arithmetic Assignment operator, = to assign the value of 0 to A. In the proceeding lines we have used both Pre & Post increment. At line 2 int B = A++; the operation being post increment, the value of A i.e 0 is assigned to B followed by the increment of A's value. At line 3 int C = ++A; the current value of A, i.e. 1 is incremented by 1 following which the new value of A is assigned to C. Therefore, the value of A = 2, B = 0 and C = 2.

Comparison Operators - These operators are to compare two values and return the result as either 'true' or 'false'.

Logical Operators - These operators are used to perform logical operations and return the result as either 'true' or 'false'.

Displaying Variables

We us the WriteLine method to display the value stored in variables.

Displaying Single Variable
CODE
int A = 6;
Console.WriteLine(A);

Displaying Multiple Variables
CODE
int A = 6, B = 9;
Console.WriteLine("{0},{1}", A, B);

Notice the code "{0},{1}". This is the format for the output to be generated by WriteLine. Since, we are displaying two variables, we need to specify the format accordingly. Here {0} and {1} represent where the proceeding variables A & B will be displayed. Now take a look at the following code snippet:-
CODE
int A = 6, B = 9;
Console.WriteLine("The value of A = {0} and B = {1}", A, B);

The output of these lines would be: The value of A = 6 and B = 9. As you can see, the {0} and {1} are replaced by the variables A and B. 0 and 1 correspond to the index of the variables following the format, starting from 0.

Comments

Software applications are made by a group of coders. Each one of them handles various aspects of the application. Its important to write descriptive texts in order to help other coders understand, the mechanism of the codes you have written. We use comments denoted by // or /* and */ for this very purpose. Example usage:-

CODE
// This is a comment
/* These are two lines
of comments */

Note: The compiler ignores all comment entries. // is used for single line of comment while /* and */ are used for multiple lines.

What's in a Semicolon?

Whitespace except when used inside quotes, is ignored in C#. All statements in C# are terminated by using the semicolon. This allow spanning of codes across multiple lines.

The following lines of code are functionally equivalent.

CODE
int A = 6, B = 9; Console.WriteLine("A + B = {0}", A + B); Console.ReadLine();

CODE
int A = 6, B = 9;
Console.WriteLine("The sum of {0} and {1} = {2}", A, B, A + B);
Console.ReadLine();