There are naming conventions for variables, and it is good practice to follow them, as shown in the following table:

The following code block shows an example of declaring and initializing a local variable by assigning a value to it. Note that you can output the name of a variable using a keyword introduced in C# 6, that is, nameof:

    // let the height variable become equal to the value 1.88 
    double heightInMetres = 1.88; 
    Console.WriteLine($"The variable {nameof(heightInMetres)} has the
    value {heightInMetres}."); 

When you assign to a variable, you often assign a literal value. A literal is notation that represents a fixed value. Data types have different notations for their literal values.

For text, a single letter, such as A, is stored as a char type and is assigned using single quotes around the literal value:

    char letter = 'A'; 

For text, multiple letters, such as Bob, are stored as a string type and are assigned using double quotes around the literal value:

    string name = "Bob"; 

Numbers are data that we want to perform an arithmetic calculation on, for example, multiplying.

Numbers can be natural numbers, such as 42, used for counting (also called whole numbers); they can also be negative numbers, such as -42 (called integers); or, they can be real numbers, such as 3.9 (with a fractional part), which are called single or double-precision floating point numbers in computing.

    int myIntegerNumber = 23; 
    double myRealNumber = 2.3; 

You might know that computers store everything as bits. A bit is either 0 or 1. This is called a binary number system. Humans use a decimal number system.

    int decimalNotation = 2_000_000; // 2 million 
    int binaryNotation = 0b_0001_1110_1000_0100_1000_0000; // 2 million 
    int hexadecimalNotation = 0x_001E_8480; // 2 million 

Storing real numbers

Computers cannot always exactly represent floating point numbers. The float and double types store real numbers using single and double precision floating points.

The following table shows how a computer stores the number 12.75. Note the 1 bits in the 8, 4, ½, and ¼ columns.

8 + 4 + ½ + ¼ = 12¾ = 12.75.

128	64	32	16	8	4	2	1	.	½	¼	1/8	1/16
0	0	0	0	1	1	0	0	.	1	1	0	0

So, 12.75 in decimal is 00001100.1100 in binary.

As you can see, the number 12.75 can be exactly represented using bits. However, some numbers can't, as you will see shortly.

Using Visual Studio 2017

In Visual Studio 2017, click on File | Add | New Project.... In the Add New Project dialog, in the Installed | Templates list, select Visual C#. In the list at the center, select Console App (.NET Core), type the name Ch02_Numbers, and then click on OK.

In the Solution Explorer window, right-click on the solution and select Properties or press Alt + Enter. For Startup Project, select Current selection. From now on, you can simply click on a project in the Solution Explorer and then press Ctrl + F5 to save, compile, and run that project, as shown in the following screenshot:

Using Visual Studio Code

Create a new folder inside the Chapter02 folder named Ch02_Numbers.

In Visual Studio Code, open the Ch02_Numbers folder and use the Integrated Terminal to create a new console application using the command dotnet new console. When you open the Program.cs file, you will be prompted to restore packages.

    Console.WriteLine($"int uses {sizeof(int)} bytes and can store
    numbers in the range {int.MinValue:N0} to {int.MaxValue:N0}."); 
    Console.WriteLine($"double uses {sizeof(double)} bytes and can
    store numbers in the range {double.MinValue:N0} to
    {double.MaxValue:N0}."); 
    Console.WriteLine($"decimal uses {sizeof(decimal)} bytes and can
    store numbers in the range {decimal.MinValue:N0} to
    {decimal.MaxValue:N0}.");

int uses 4 bytes and can store numbers in the range -2,147,483,648 to
2,147,483,647.
double uses 8 bytes and can store numbers in the range -
179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,0 00,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00 0,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 ,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000, 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,0 00,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 to  179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,0 00,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00 0,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 ,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000, 000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,0 00,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.
decimal uses 16 bytes and can store numbers in the range - 
79,228,162,514,264,337,593,543,950,335 to
79,228,162,514,264,337,593,543,950,335.

    double a = 0.1; 
    double b = 0.2; 
    if (a + b == 0.3) 
    { 
      Console.WriteLine($"{a} + {b} equals 0.3"); 
    } 
    else 
    { 
      Console.WriteLine($"{a} + {b} does NOT equal 0.3"); 
    } 

0.1 + 0.2 does NOT equal 0.3

    decimal c = 0.1M; // M indicates a decimal literal value 
    decimal d = 0.2M; 
    if (c + d == 0.3M) 
    { 
      Console.WriteLine($"{c} + {d} equals 0.3"); 
    } 
    else 
    { 
      Console.WriteLine($"{c} + {d} does NOT equal 0.3"); 
    } 

0.1 + 0.2 equals 0.3

Booleans can only contain one of the two values: true or false, as shown in the following code. They are most commonly used to branch and loop, as you will see in Chapter 3, Controlling the Flow, Converting Types, and Handling Exceptions:

    bool happy = true; 
    bool sad = false; 

There is a special type named object that can store any type of data, but its flexibility comes at the cost of messier code and poor performance due to boxing and unboxing operations when storing a value type. You should avoid it whenever possible.

Add a new console application project named Ch02_Variables and add the following code to the Main method:

    object height = 1.88; // storing a double in an object 
    object name = "Amir"; // storing a string in an object 
    int length1 = name.Length; // gives compile error! 
    int length2 = ((string)name).Length; // cast to access members 

The object type has been available since the first version of C#, but C# 2 and higher versions have a better alternative called generics, which we will cover later, that provide the flexibility we want without the performance overhead.

There is another special type named dynamic that can also store any type of data, and like object, its flexibility comes at the cost of performance. Unlike object, the value stored in the variable can have its members invoked without an explicit cast, as shown in the following code:

    // storing a string in a dynamic object 
    dynamic anotherName = "Ahmed";  
    // this compiles but might throw an exception at run-time! 
    int length = anotherName.Length;  

The limitation of dynamic is that Visual Studio cannot show IntelliSense to help you write the code because the compiler doesn't check at build time. Instead, the CLR checks for the member at runtime. The dynamic keyword was introduced in C# 4.

Local variables are declared inside methods and they only exist during the call to that method. Once the method returns, the memory allocated to any local variables is released.

Enter the following code to declare and assign values to some local variables inside the Main method. Note that we specify the type before the name of each variable:

    int population = 66_000_000; // 66 million in UK 
    double weight = 1.88; // in kilograms 
    decimal price = 4.99M; // in pounds sterling 
    string fruit = "Apples"; // strings use double-quotes 
    char letter = 'Z'; // chars use single-quotes 
    bool happy = true; // Booleans have value of true or false 

    var population = 66_000_000; // 66 million in UK 
    var weight = 1.88; // in kilograms 
    var price = 4.99M; // in pounds sterling 
    var fruit = "Apples"; // strings use double-quotes 
    var letter = 'Z'; // chars use single-quotes 
    var happy = true; // Booleans have value of true or false 

    // good use of var 
    var xml1 = new XmlDocument(); 
    // unnecessarily verbose repeating XmlDocument 
    XmlDocument xml2 = new XmlDocument(); 
 
    // bad use of var; what data type is file1? 
    var file1 =
      File.CreateText(@"C:something.txt"); 
    // good use of a specific type declaration 
    StreamWriter file2 = 
      File.CreateText(@"C:something.txt"); 

Most of the primitive types except string are value types. This means they must have a value. You can determine the default value of a type using the default() operator. The default value of an int variable is 0 (zero):

    Console.WriteLine($"{default(int)}"); // 0 
    Console.WriteLine($"{default(bool)}"); // False 
    Console.WriteLine($"{default(DateTime)}"); // 1/01/0001 00:00:00 

Strings are reference types. This means that they contain the memory address of a variable, not the value of the variable itself. A reference type variable can have a null value. The null value is a special literal value that indicates that the variable does not reference anything (yet).

Sometimes, it is convenient to allow a value type to be null. You can do this by adding a question mark as a suffix to the type when declaring a variable, as shown in the following code:

    int ICannotBeNull = 4; 
    int? ICouldBeNull = null; 
    Console.WriteLine(ICouldBeNull.GetValueOrDefault()); // 0 
    ICouldBeNull = 4; 
    Console.WriteLine(ICouldBeNull.GetValueOrDefault()); // 4  

    // check is myVariable is not null before using it 
    if (ICouldBeNull != null) 
    { 
      // do something with ICouldBeNull 
    } 

    string authorName = null; 
    // if authorName is null, instead of throwing an exception, 
    // null is returned 
    int? howManyLetters = authorName?.Length; 

    // result will be three if howManyLetters is null 
    var result = howManyLetters ?? 3; 
    Console.WriteLine(result); 

When you need to store multiple values of the same type, you can declare an array. For example, you might need to store four names in a string array.

The following code declares an array for storing four string values. Then, it stores string values at index positions 0 to 3 (arrays count from zero, so the last item is one less than the length of the array). Finally, it loops through each item in the array using a for statement that we will cover in more detail in Chapter 3, Controlling the Flow, Converting Types, and Handling Exceptions.

Add the following lines of code to the end of the Main method:

    // declaring the size of the array 
    string[] names = new string[4]; 
    // storing items at index positions 
    names[0] = "Kate"; 
    names[1] = "Jack"; 
    names[2] = "Rebecca"; 
    names[3] = "Tom"; 
    for (int i = 0; i < names.Length; i++) 
    { 
      Console.WriteLine(names[i]); // read the item at this index 
    }