Learn about the basics of data types and creating variables in C#. 

Data Types and Variables 

When we use data in our programs, it's good practice to save them in a _variable_. A variable is basically like a box in our computer memory where we can store values used in our code.

In C#, data types and variables are closely intertwined. Remember how C# is strongly-typed? Every time we declare a variable, we have to specify what kind of data type that variable is going to hold. 

There are two ways we can assign variables. We can do it on two lines:

```csharp
// Declare an integer
int myAge;
myAge = 32;
```

Or, we can be more concise and just do it on one:

```csharp
// Declare a string
string countryName = "Netherlands";
```
 
In each case, we first write the data type, then the variable name, then use the equals sign `=` to assign the variable a value.

Once we've defined a variable, we can use them throughout our program. For example, here's a short program that prints a few math equations to the console:

```csharp
int evenNumber = 22;
int oddNumber = 45;
Console.WriteLine(evenNumber + oddNumber); // Prints 67
Console.WriteLine(oddNumber - evenNumber); // Prints 23
```

If we want to change the values, it's only necessary to change it in one place instead of everywhere it is used. 

Creating Variables with Types

Congratulations! In this lesson, you learned about how data types and variables work in C#. Topics covered include:

- C# built-in data types, including `int`, `double`, `char`, `string`, and `bool`
- How to create, name, and use variables
- Common errors you might encounter 
- Converting data types from one to another

For more information on using types and declaring variables, check out [Microsoft's C# documentation](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/). 

Want to keep track of the different data types? Download [this handy cheatsheet](https://content.codecademy.com/courses/learn-c-sharp/data-types-variables/C%23%20Data%20Types%20Cheat%20Sheet.pdf).

Now that you know a few things about variables and data types, try writing a program that:
- Converts a boolean to a string
- Changes a string to a list of chars 
- Converts a data type we didn't cover to another data type!


Review

Because variables have to be strictly typed, there may be some circumstances where we want to change the type of data a variable is storing. This strategy is known as _data type conversion_. 

For example, let's try converting a double to an integer:

```csharp
double myDouble = 3.2;

// Round myDouble to the nearest whole number
int myInt = myDouble;
```
But if you tried to run this code, it wouldn't work. Sorry.

However, if you did the reverse and turned an int into a double:
```csharp
int myInt = 3;
// Turn it into a double
double myDouble = myInt;
```

It's fine! Why is that? 

C# checks to make sure that when we convert data types from one to another that we're not losing any data, because that could cause problems in our code. 

Because of that, there are a couple different ways to do data type conversion: 
- _implicit_ conversion: happens automatically if no data will be lost in the conversion. That's why it's possible to convert an int (which can hold less data) to a double (which can hold more), but not the other way around.  
- _explicit_  conversion: requires a cast operator to convert a data type into another one. So if we do want to convert a double to an int, we could use the operator `(int)`.

So, if we're to fix the error in our previous code, we'd rewrite it as follows:

```csharp
double myDouble = 3.2;

// Round myDouble to the nearest whole number
int myInt = (int)myDouble;
```

It's also possible to convert data types using built-in methods. For most data types, there is a `Convert.ToX()` method, like `Convert.ToString()` and `Convert.ToDouble()`. For a full list of `Convert` class built-in methods, check out the [Microsoft Documentation](https://docs.microsoft.com/en-us/dotnet/api/system.convert?view=netframework-4.7.2). 

Converting Data Types

When you program, you'll come across a lot of errors. And that's ok! And when you're first starting to learn a strongly-typed language, errors can be pretty common. 

So, what happens if you forget to specify a data type for your variable?: 
```csharp
randomData = "asdf jskdf";
Console.WriteLine(randomData);
```

C# will give an error because it doesn't want you to have random data being used in your application. The error will look something like this:

```error
The name 'randomData' does not exist in the current context [CS0103:] 
``` 

If you use the wrong type definition, like an `int` when it's supposed to be a `double`:

```csharp
int score = 45.39;
```

You might see an error like this:

```error
Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)
```

We also want to watch out for how we name our variables. It's good practice to use `camelCase` styling, and they should only contain underscores, letters, and digits. 

```csharp
string iAmAVariable;
string i'mnot; // this will cause errors
```

There are also a few words that you can't use. These are known as _reserved keywords_. [Reserved keywords](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/) are words that the language uses, so they already have specific definitions that shouldn't be re-written. If we use one of them as a variable name, we risk overwriting it and causing significant errors in our program. For example, we can't name a variable `string` because that word is reserved for defining data types. 

Lastly, it's important to double-check spelling and punctuation! Don't forget to end each statement with a semicolon `;`. 

Luckily, many IDEs will point out these potential errors before we even run our code! But it's still good to be prepared to handle these errors if you should see them, including when you're coding on Codecademy. 


Handling Errors

When we write programs, we're telling the computer how to process pieces of information, like the numbers in a calculation, or printing text to the screen. So how does a computer distinguish between a number and a character? Why is it important to be able to tell the difference? 

Languages like C# tell a computer about the type of data in its program using _data types_. 
Data types represent the different types of information that we can use in our programs and how they should be used. 

Without data types, computers would try and perform processes that are impossible, like squaring a piece of text or capitalizing a number. That's how we get bugs!

C# is _strongly-typed_, so it requires us to specify the data types that we're using. It is also _statically-typed_, which means it will check that we used the correct types before the program even runs. Both language features are important because they help write scalable code with fewer bugs.  

Using types will come up in several different places when learning C#. To start, we'll examine how types impact variable declaration and the usage of different data types in a program.

In this lesson, we'll look at:
- Common C# data types 
- How to create variables that are statically typed  
- How to convert variables from one data type to another


Introduction to Data Types and Variables in C#

_Data types_ tell us a few things about a piece of data, like:
- How it can be stored
- What operations we can perform with it 
- Different methods it can be used with

Data types are present in all programming languages, but are particularly important in C#. That's because C# is known as a strongly-typed language&mdash;it requires that the programmer _specify the data type of every value and expression_. While it means writing more code, using types has long term benefits like built-in documentation and increased readability. 

As we can see to the diagram to the right, C# has several built-in data types. You don't need to memorize all of them, but pay specific attention to these common ones that we'll use throughout our lessons: 
- `int` - whole numbers, like: 1, -56, 948
- `double` - decimal numbers, like: 239.43909, -660.01
- `char` - single characters, like: "a", "&", "£"
- `string` - string of characters, like: "dog", "hello world"
- `bool` - boolean values, like: true or false 


Diagram of different C# data types, including bool, int, and string. 