Variables and types

What is a variable?

A variable is a named box that holds a value. You give it a type (what kind of value can go in the box) and a name (so you can refer to it later):

int age = 36;
//│    │     └── the value
//│    └──────── the name
//└───────────── the type

You can change what's in the box later — but only to another value of the same type:

int age = 36;
age = 37;          // ✅ fine
age = age + 1;     // ✅ now 38
age = "old";       // ❌ compile error: a string is not an int

The built-in types you'll use most

Notice the m suffix on 19.99m. Without it, 19.99 is a double, and C# won't silently turn it into a decimal.

Naming rules

• Use camelCase for local variables: firstName, totalPrice.
• Names can contain letters, digits and _, but can't start with a digit.
• Names are case-sensitive: age and Age are different variables.
• Pick names that describe the value: daysUntilDeadline beats d.

var — let the compiler infer the type

When the type is obvious from the right-hand side, you can write var:

var city = "Casablanca";   // string
var year = 2026;           // int
var ratio = 0.75;          // double

The variable still has a fixed type — var just saves you from typing it. You can't write var x; without a value, because the compiler would have nothing to infer from.

const — values that never change

const int MaxLoginAttempts = 5;
const double Pi = 3.14159;
 
MaxLoginAttempts = 6;  // ❌ compile error

Use const for fixed values known at compile time. Constants are conventionally named in PascalCase.

Converting between types

Implicit conversions happen automatically when no data can be lost:

int whole = 10;
double d = whole;      // ✅ 10.0 — every int fits in a double

Explicit conversions (casts) are required when data might be lost:

double price = 9.99;
int rounded = (int)price;   // 9 — the .99 is cut off, not rounded!

Parsing turns text into a number:

int a = int.Parse("123");            // 123
int b = int.Parse("hello");          // 💥 throws FormatException at runtime
 
if (int.TryParse("hello", out int c))
    Console.WriteLine(c);
else
    Console.WriteLine("Not a number"); // ✅ safe: no exception

Try it

Run this, then experiment: change "42" to "forty-two", or remove the (int) cast and read the compiler error.

Putting values into strings

String interpolation — a $ before the string, and expressions in {braces} — is the cleanest way to build text:

string name = "Ada";
int age = 36;
 
Console.WriteLine($"{name} is {age} years old.");
// Ada is 36 years old.
 
Console.WriteLine($"Next year she'll be {age + 1}.");
// Next year she'll be 37.

Key takeaways

• A variable = type + name + value, and its type never changes.
• int for whole numbers, double for measurements, decimal for money, bool, char, string.
• var infers the type; const makes a value unchangeable.
• Widening conversions are implicit; narrowing ones need a cast; text needs Parse/TryParse.