# Beginning C# – Variables and operations

So you’re sick with Hello World program code, and want to start doing something. Before you go writing your NASA-approved quantum space engine or the next blockbuster financial application, you have to know about how programs store and manipulate data.

Program data (such as rocket speed or stock prices) are stored in variables, which can be thought of as boxes holding information. We remember information differently from a computer. For example, the information “15” can be a number to us. Or part of an address such as “street 15”. Or 15 dollars. We can pretty much move this data around in our heads.

Here’s the thing: computers need structure. They must know that 15 is a number, and will only store 15 as a number. If 15 is to be part of an address, it must be stored as an address. Moving data from one form to another usually requires telling the computer explicitly to do so, which means you have to write specific code to do that. It’s easier to talk to a computer in its own terms, so we’ll learn about …

Variable types
There are a few variable types, and the most commonly used are those storing numbers and text. There are 2 kinds of number variables; whole numbers and numbers with decimal points (also known as real numbers). In C#, the whole number variables are `byte`, `short` and `int`. The other kind has `float`, `double` and `decimal`. There are more, but these are the common ones.

Why is there a difference? Because computers think, store and manipulate them differently. To the computer, a 7 and a 7.00 are two very different pieces of information. This is very important, especially if you’re doing mathematical calculations.

So we’ll go through them a little bit

• byte – a whole number between 0 and 255 inclusive
• short – a whole number between -32768 and 32767 inclusive
• int – a whole number between -2147483648 and 2147483647 inclusive
• float – a real number approximately between ±10-45 and ±1038
• double – a real number approximately between ±10-323 and ±10308
• decimal – a real number approximately between ±10-28 and ±1028

Why are the real numbers approximations? Again it’s due to the way computers store data. `float `and `double `variable types implement the IEEE standard. For now, we’ll simply learn more about these variable types through practical use. Which brings us to the sample code.

```using System;
using System.Collections.Generic;
using System.Text;

namespace VariablesAndOperations
{
class Program
{
static void Main(string[] args)
{
int number;
double anothernumber, yetanothernumber;

number = 5;
anothernumber = 3.14159;
yetanothernumber = 2 * anothernumber;

Console.WriteLine(number);
Console.WriteLine(anothernumber);
Console.WriteLine(yetanothernumber);

number = 3 + 8;
Console.WriteLine(number);

// This indicates the end of the program

Console.WriteLine("End of program");
}
}
}
```

A closer look
The first two lines inside the Main function is

```int number;
double anothernumber, yetanothernumber;
```

This is how we declare our variables. In this case, we tell the computer we want a variable of type `int `and we name it “number”. We also declare two variables of type `double`, named (unimaginatively) “anothernumber” and “yetanothernumber”. Variables of the same type can be declared on the same line by separating them with a comma.

The next three lines are

```number = 5;
anothernumber = 3.14159;
yetanothernumber = 2 * anothernumber;
```

This is where we assign values to our variables. So we want the integer 5 to be stored in “number”. Then we want 3.14159 to be stored in “anothernumber”. The next line is more interesting. We want two times the value stored in “anothernumber” to be stored in “yetanothernumber”. This means we can assign any appropriate value to a variable, even if the value is stored in another variable.

Manipulating data basically involves mathematical operations (although they are others). They are addition, subtraction, multiplication and division. Their respective operations in code are +, -, * and /.

Commenting
Skipping a couple lines down, we encounter the double forward slash //. This simply tells the computer that whatever follows after the // on the same line is to be ignored, because it’s meant to be read by a human.

If you’ve tried running the previous Hello World program straight from the directory by double clicking, you’ll find that it comes up and then disappears. Which is what the following lines will prevent:

```Console.WriteLine("End of program");
```

By printing “End of program”, you’ll know that the program has indeed reached the end. The `Console.ReadLine();` tells the computer to wait for input till the Enter/Return key is hit. This automatically solves the disappearing problem.

Here’s the source code for you to play with.

Homework
Try assigning

```number = 1 / 4;
anothernumber = 1.0 / 4.0;
```

and print out the answer! Can you figure out why the values aren’t what you think they should be?