📝 Lesson 2.1: Variables and Data Types

What Is a Variable?

A variable is a named container that holds a piece of information while your program runs. You put a value into it, and later you can read it back or change it — all by referring to its name.

The classic analogy is a labeled box. You write a label on the box (the variable's name), and you put something inside it (the value). When you need what's inside, you just ask for the box by its label.

Declaring and Assigning

Before you use a variable in C#, you declare it: you state its type (what kind of value it holds) and its name. Here's the pattern:

// type   name  =  value ;
int age = 30;

Reading that line: "Make an int (whole number) called age, and put 30 in it." Let's name the parts:

• Declaration — introducing the variable with a type and name: int age;
• Assignment — putting a value in it using the = sign: age = 30;
• You can do both at once (as above), which is the most common style.

Once declared, you can change a variable's value by assigning again — no type needed the second time:

int score = 10;
Console.WriteLine(score);   // 10

score = 25;                 // reassign
Console.WriteLine(score);   // 25

score = score + 5;          // use the old value to make the new one
Console.WriteLine(score);   // 30

10
25
30

The Core Data Types

The type tells C# what kind of data a variable holds and what you can do with it. Here are the ones you'll use constantly:

Here they are in action:

int age = 30;
double height = 1.75;          // meters
decimal price = 19.99m;        // note the 'm' suffix for decimal
bool isStudent = true;
char grade = 'A';
string name = "Ada Lovelace";

Console.WriteLine(name);       // Ada Lovelace
Console.WriteLine(age);        // 30
Console.WriteLine(isStudent);  // True

Why Types Matter (Type Safety)

C# is a strongly typed (or "type-safe") language. Once a variable has a type, it can only hold values of that type. Try to put the wrong kind of value in, and the program won't even compile:

int age = 30;
age = "thirty";   // ❌ Error! Can't put text into an int

Cannot implicitly convert type 'string' to 'int'

This might feel strict, but it's one of C#'s biggest gifts to you as a beginner. The compiler catches a whole category of mistakes before your program ever runs, and the error message tells you exactly what went wrong and where.

💡 Think of it as guardrails: Types are labels on your boxes that also enforce what's allowed inside. A box labeled "whole numbers" simply refuses text — so you can't accidentally mix things up later.

The var Keyword

When you assign a value as you declare a variable, C# can often figure out the type for you. The var keyword says "you work out the type from the value on the right":

var age = 30;             // C# infers: int
var name = "Ada";         // C# infers: string
var price = 19.99m;       // C# infers: decimal
var isReady = true;       // C# infers: bool

These are exactly the same as writing the type explicitly — var is a convenience, not a different kind of variable. The variable is still strongly typed; C# just saves you from repeating the type.

var mystery;   // ❌ Error — no value to infer the type from

Constants and Naming

Constants

Sometimes a value should never change while the program runs — like the number of days in a week, or a tax rate. Mark it with const, and C# will refuse any attempt to change it:

const int DaysInWeek = 7;
const double Pi = 3.14159;

// DaysInWeek = 8;   // ❌ Error — a const can't be reassigned

Constants make your intent clear and prevent accidental changes to values that should stay fixed.

Naming rules and conventions

C# has a few rules (must-follow) and some conventions (strongly recommended style):

💡 Names are documentation: Good variable names make code read almost like plain English. totalPrice tells the reader far more than tp or x. C# is also case-sensitive, so age and Age are two different names.

Putting It Together

Here's a small program that stores a profile using several types, then prints it. Create a project (dotnet new console -o Profile), paste this into Program.cs, and run it:

// A simple profile using several data types
string name = "Ada Lovelace";
int birthYear = 1815;
double favoriteNumber = 42.5;
bool likesCoding = true;
char initial = 'A';

Console.WriteLine("Name: " + name);
Console.WriteLine("Birth year: " + birthYear);
Console.WriteLine("Favorite number: " + favoriteNumber);
Console.WriteLine("Likes coding: " + likesCoding);
Console.WriteLine("Initial: " + initial);

Name: Ada Lovelace
Birth year: 1815
Favorite number: 42.5
Likes coding: True
Initial: A

Notice the + between text and a variable. When one side is a string, + joins (concatenates) them into one piece of text, automatically converting the number or bool to its text form. (In the next lesson we'll meet a cleaner way to do this called string interpolation.)

Exercise & Quiz

// TODO: pick the correct type for each variable
const string StoreName = "Ada's Shop";
string productName = "Notebook";
// int quantity = ...;
// decimal unitPrice = ...;
// bool inStock = ...;

Console.WriteLine("Store: " + StoreName);
Console.WriteLine("Product: " + productName);
// print the rest...

const string StoreName = "Ada's Shop";
string productName = "Notebook";
int quantity = 3;
decimal unitPrice = 2.50m;
bool inStock = true;

Console.WriteLine("Store: " + StoreName);
Console.WriteLine("Product: " + productName);
Console.WriteLine("Quantity: " + quantity);
Console.WriteLine("Unit price: " + unitPrice);
Console.WriteLine("In stock: " + inStock);

Store: Ada's Shop
Product: Notebook
Quantity: 3
Unit price: 2.50
In stock: True

Summary

📚 Additional Resources

• Types — C# Programming Guide
• Built-in types reference
• Naming rules and conventions

🚀 What's Next?

Now that your programs can store data, the next step is to work with it. In Lesson 2.2: Operators and Expressions, you'll do math, compare values, and combine true/false conditions.