C# is statically typed: it verifies every type at compile time — before the program runs — instead of discovering mismatches mid-execution. Moving the check to the very start buys four things:

• Mistakes caught early — mixing a string and an int simply won't compile, so a whole class of bugs never ships.
• Faster execution — types are already settled, so the runtime never stops to ask "what is this?"
• Leaner memory — knowing each value's size up front lets the runtime lay data out tightly.
• Smarter tools — your editor knows every type as you type, powering accurate autocomplete and safe refactors.

Every type in C# is either a value type (the variable holds the data itself) or a reference type (the variable holds an address pointing to data that lives elsewhere). That single split shapes how data is copied, compared and stored.

flowchart TD
    T["C# type"] --> V["Value type — holds the data"]
    T --> R["Reference type — holds an address"]
    V --> ST["struct"]
    V --> E["enum"]
    R --> C["class"]
    R --> I["interface"]

Assigning a value type copies the data; the two variables are now independent. Assigning a reference type copies the address, so both names point at the same object.

int a = 10;
int b = a;   // b gets a copy
b = 99;      // a is untouched
// a is still 10

int[] x = { 1, 2, 3 };
int[] y = x;   // same array
y[0] = 99;
// x[0] is now 99 too

This one idea quietly decides everyday behaviour:

• Whether changing one variable affects another.
• What a method can and can't change when you pass data into it.
• How equality and copying behave.

Keep it in the back of your mind — and we'll make it physical in the Memory section, where you'll see exactly where each family lives.

C# bakes in a handful of simple types for the most basic data — whole numbers, decimals, single characters, true/false — each with a short keyword name. Every keyword is just a friendly alias for a .NET type: int really is System.Int32.

int health = 100;
double speed = 5.5;
char grade = 'A';
bool isAlive = true;

People borrow the word "primitive" from languages like Java, but in C# it's not quite right. C# has no formal "primitive" category — its simple types are really structs: full value types with methods of their own.

You can write 5.ToString() or read int.MaxValue; a true primitive couldn't do that. So the accurate term is simple type.

Picking a number type is a trade between range (how big) and precision (how exact).

A bare decimal literal is a double; a bare whole number is an int. The suffix tells the compiler you meant something else.

int   lives   = 3;
float gravity = -9.81f;   // f — without it, 9.81 is a double
double pi     = 3.14159;  // double by default
decimal price = 19.99m;   // m — exact, for currency

double pi = 3.14159;  // fine, 3.14159 is already double
float gravity = -9.81; // ERROR — can't assign double to float without losing precision
decimal price = 19.99; // ERROR — can't implicitly convert double to decimal

Integer division truncates (7 / 2 is 3), so promote to a decimal type when you need the fraction: 7 / 2.0 is 3.5.

A bool usually comes from a comparison, and it drives every conditional and loop your program runs.

bool isAlive  = true;
bool canEnter = health > 0;   // a comparison produces a bool

if (isAlive)
{
    Console.WriteLine("Keep playing");
}

A char is the building block strings are made of. Its literal uses single quotes — 'A' — while a string uses double quotes — "A". Don't mix them up.

Under the hood a char is a 16-bit Unicode (UTF-16) code unit — so each character is a number you can do arithmetic on.

char letter = 'A';
int code = letter;   // 65 — the Unicode value of 'A'

Declare the set of names, then use them by name. The code reads like English, and the compiler refuses any value outside the set.

enum Direction { North, East, South, West }

Direction facing = Direction.North;

if (facing == Direction.North)
{
    Console.WriteLine("Heading north");
}

Each member is really a number — by default an int starting at 0. You can set the values, change the underlying type, or mark it [Flags] to combine members like switches (give each a distinct power of two).

enum Difficulty : byte
{
    Easy   = 1,
    Normal = 2,
    Hard   = 4
}

[Flags]
enum Toppings
{
    None   = 0,
    Cheese = 1,
    Bacon  = 2
}
var o = Toppings.Cheese | Toppings.Bacon;

A string is a sequence of characters — player names, dialogue, anything textual. Unlike the numeric and char types it's a reference type: the variable holds a reference to the text, which lives elsewhere.

Yet it behaves like a simple value, because strings are immutable — once created they never change. You can share one freely without fear someone will alter it underneath you. (Full treatment comes in its own section later.)

Write strings in double quotes. Join them with +, or — better — use $ interpolation to drop values straight in.

string name = "Aria";
string greeting = "Hello, " + name;
string line = $"{name} scored {1500} points";

That's enough to get going. Immutability, memory cost and StringBuilder get a section of their own.

An operator is a symbol that performs an action on one or more values — its operands. You've already met = and +. The common ones fall into a few families.

Often you need a value as a different type — an int used as a double, or text turned into a number. C# is strict about when this happens automatically and when you must ask for it.

int whole = 7;
double precise = whole;  // 7 -> 7.0

double d = 9.8;
int n = (int)d;          // 9 — truncated

Casting between number types truncates; it doesn't round.

To move between text and numbers, use library methods rather than casts:

int n = int.Parse("42");               // string -> int (throws on bad input)
bool ok = int.TryParse("42", out n);   // safe: reports failure, never crashes
string s = 42.ToString();              // int -> string
double d = Convert.ToDouble("3.14");

Prefer TryParse for anything a user typed — it returns false instead of throwing.

Languages differ along two independent axes, and together they decide how many mistakes the compiler can catch for you:

• Strong vs weak — a strongly typed language enforces types and won't silently treat text as a number; a weakly typed one lets types bend, which is flexible but error-prone.
• Static vs dynamic — static typing checks at compile time; dynamic typing checks while the program runs.

Every variable has a known type at compile time, and illegal mixes are rejected before the program ever runs.

int x = 5;
x = "hello";   // compile error — caught immediately

A weakly typed language might have quietly allowed that and misbehaved much later. The trade is a little more typing up front, in exchange for fewer runtime surprises and far better tooling. For games, catching a type bug at compile time beats finding it during a live demo.

Strictly, C# has no free-floating functions — every function belongs to a type and is called a method (we meet those properly in the OOP section).

But top-level statements let us declare local functions and call them as if they stood alone. It's a convenient pretence, so we can learn the idea before learning classes.

Parameters are the named inputs in a function's definition. Arguments are the actual values you pass when you call it.

void Greet(string name)   // 'name' is a parameter
{
    Console.WriteLine($"Hello, {name}");
}

Greet("Aria");   // "Aria" is the argument

A function's return type declares what it hands back; return sends that value and ends the function. A function that acts but hands nothing back has the return type void.

int Square(int n)
{
    return n * n;
}
int r = Square(5);   // 25

void PrintScore(int score)
{
    Console.WriteLine($"Score: {score}");
}
PrintScore(1500);

Pass arguments by name to make a call self-documenting and order-free. Give a parameter a default value and callers may omit it — optional parameters must come after all required ones.

void Attack(int damage, bool critical = false) { /* ... */ }

Attack(10);                       // critical defaults to false
Attack(10, critical: true);       // named — clear at the call site
Attack(damage: 25);               // order wouldn't matter

params lets a function accept any number of arguments of a type, gathered into an array — great when the count isn't fixed.

int Sum(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers) total += n;
    return total;
}

Sum(1, 2, 3);          // 6
Sum(10, 20, 30, 40);   // 100

Normally value-type arguments are copied. ref passes a variable by reference, so the function can change the caller's variable. out is similar, used to hand back extra results.

void Double(ref int n) { n *= 2; }

int x = 5;
Double(ref x);   // x is now 10

bool ok = int.TryParse("42", out int parsed);   // out returns the parsed value

When a function is a single expression, => gives a compact one-line form — no braces, no return.

int Square(int n) => n * n;
string Greet(string name) => $"Hello, {name}";

Identical behaviour to the block form, just tidier for short functions.

Scope is where a name is visible; lifetime is how long its value exists in memory. The two move together — a variable usually lives exactly as long as the block it's declared in is running.

Outside its region, the compiler doesn't even know the name exists. That's what stops unrelated parts of a program from stepping on each other's names.

Shadowing is when an inner scope declares a name that already exists in an outer one, hiding it for that region. C# forbids it for locals to prevent confusion.

int value = 10;
{
    int value = 20;   // error — already declared in an enclosing scope
}

It can still happen between a field and a local — one more reason clear names matter.

A conditional runs code only when a condition is true. It's the difference between a script that always does the same thing and one that reacts — the heart of every behaviour you'll write.

For a simple either/or that produces a value, the ternary operator ?: is a compact inline if/else. Read it as "condition ? value-if-true : value-if-false".

int health = 30;
string status = health > 0 ? "Alive" : "Dead";   // "Alive"

Perfect for short assignments. For anything with real branching, reach back for a full if.

An if can live inside another, checking a second condition only once the first holds. Useful — but deep nesting hurts readability, so keep it shallow.

if (isLoggedIn)
{
    if (hasPermission)
    {
        OpenEditor();
    }
}

When you compare one value against many fixed options, switch is cleaner than a long if/else if chain. The modern expression form returns a value directly.

switch (direction)
{
    case "N": Move(0, 1);  break;
    case "S": Move(0, -1); break;
    default:  Stay();      break;
}

string label = score switch
{
    >= 90 => "Gold",
    >= 50 => "Silver",
    _     => "Try again"
};

The expression form uses => arms and _ as the catch-all — concise for mapping one value to another.

You met arrays earlier; now the details. Size an array up front and fill it later, or initialize it with values immediately. Its length is fixed once created — it can't grow.

int[] a = new int[5];             // five zeros
int[] b = new int[] { 1, 2, 3 };  // sized from the values
int[] c = { 10, 20, 30 };         // shorthand for the same

Reach an element by its index, counting from 0. The last index is Length - 1; going out of range throws at run time.

string[] names = { "Aria", "Ben", "Cleo" };
Console.WriteLine(names[0]);    // Aria
names[2] = "Cara";              // overwrite Cleo
Console.WriteLine(names.Length); // 3
// names[3] -> IndexOutOfRangeException

Arrays can have more than one dimension — handy for grids, boards and tile maps. A 2-D array uses [,] and two indices: row and column.

int[,] grid = new int[2, 3];   // 2 rows, 3 columns
grid[0, 0] = 5;
grid[1, 2] = 9;

int[,] board = { { 1, 2 }, { 3, 4 } };

A loop runs a block of code repeatedly — to process every item in a collection, count to a number, or keep a game running frame after frame. C# offers four, each suited to a different question.

Sometimes you need to control a loop mid-flight — leaving early, or skipping a single pass. Two keywords do it: break stops the loop entirely; continue skips to the next iteration.

While your program runs, all its data lives in memory (RAM) — picture an enormous wall of numbered lockers, each holding a small piece of data. The CPU fetches and stores values by those numbers, called addresses.

Variables are really just friendly names for locations in that memory. Your code never juggles raw addresses — C# handles that for you.

In some languages you must manually free every piece of memory you allocate — and forgetting causes leaks and crashes. C# is managed: the garbage collector automatically reclaims heap objects you're no longer using.

You focus on logic; the runtime handles cleanup. We'll see how the GC actually works in the later deep-dive section.

Object-oriented programming structures a program as a set of cooperating objects, each combining state (data) with behaviour (methods). It exists to tame the complexity that sinks large procedural programs:

• Group related data and behaviour so they evolve together.
• Hide internals, so changes stay local and safe.
• Encourage reuse through inheritance and shared contracts.

Each pillar gets its own treatment in the sections ahead. C# implements them with class/struct, access modifiers, : for inheritance, virtual/override, and abstract/interface.

Remember the compiler wrapping your code in a class with a Main method? Now it makes sense: there is no code outside a class in C#. Your program was always a class.

class Program
{
    static void Main(string[] args)
    {
        // your top-level code lived here
    }
}

The training wheels are off — everything is objects and classes.

An object's raw data lives in fields, but we usually expose it through properties — a gateway that looks like a field but can run code on read or write.

public int health;   // anyone can set
                     // any value, no control

private int health;
public int Health
{
    get => health;
    set => health = value < 0 ? 0 : value;
}

Rule of thumb: keep fields private, expose data through public properties.

When you need no custom logic, an auto-property gives the property syntax with a hidden backing field generated for you — the everyday default. The set receives the new value through the implicit value keyword; omit or restrict it to control access.

class Player
{
    public string Name { get; set; }
    public int Health { get; private set; }   // read-only from outside
}

A constructor runs once, when you new an object, to set it up — guaranteeing it starts life valid. It's named after the class and has no return type. If you write none, C# supplies a hidden default constructor; the moment you write your own, that freebie disappears.

class Player
{
    public string Name;
    public int Health;

    public Player(string name, int health)
    {
        Name = name;
        Health = health;
    }
}

Player hero = new Player("Aria", 100);

One constructor can call another with : this(...), avoiding duplicated setup. This is chaining.

public Player() : this("Unnamed", 100)
{
    // delegates to the constructor below
}

public Player(string name, int health)
{
    Name = name;
    Health = health;
}

Unity's Vector3 and Color are structs for exactly these reasons. When in doubt, use a class.

Generics let you write a class or method with a type placeholder — written <T> by convention — filled in when it's used. You get reuse and full type safety: no casting, no losing track of types. You've used them every time you wrote List<...>.

List<int> numbers = new List<int>();      // T is int
List<string> names = new List<string>();  // T is string

Sometimes T must meet a requirement — be a class, have a constructor, implement an interface. The where clause adds those constraints, unlocking what you can do with T.

T CreateAndReturn<T>() where T : new()
{
    return new T();   // allowed: T must have a constructor
}

void Print<T>(T item) where T : IComparable { /* ... */ }

• A local value type lives in the stack frame and dies with it.
• A reference type lives on the heap; the stack holds only a reference to it.
• A value type inside a class object lives on the heap too — wherever its owner lives.

So "value types are on the stack" is a useful simplification, not an absolute rule.

A List<T> is an ordered, resizable sequence of same-typed items — like an array that can grow and shrink, fully type-safe. If you reach for one collection by default, it's this.

List<string> party = new List<string> { "Aria", "Ben" };
party.Add("Cleo");          // append
party.Insert(0, "Zed");     // at a position
party.Remove("Aria");       // by value
party.RemoveAt(0);          // by index
Console.WriteLine(party.Count);

foreach (string name in party)
    Console.WriteLine(name);

for (int i = 0; i < party.Count; i++)
    Console.WriteLine($"{i}: {party[i]}");

Use foreach when you want each item, a for loop when you need the index.

A Dictionary<TKey, TValue> stores key → value pairs, so you fetch a value instantly by its key instead of scanning positions. Keys are unique; values needn't be.

Dictionary<string, int> scores = new Dictionary<string, int>
{
    ["Aria"] = 1500,
    ["Ben"]  = 1200
};

scores["Cleo"] = 900;             // add or update
scores.Remove("Ben");             // remove by key
int aria = scores["Aria"];        // read (throws if missing)

if (scores.TryGetValue("Cleo", out int c))
    Console.WriteLine(c);          // safe lookup

Loop with foreach; each item is a KeyValuePair with .Key and .Value.

foreach (KeyValuePair<string, int> entry in scores)
{
    Console.WriteLine($"{entry.Key}: {entry.Value}");
}

Inheritance lets one class build on another, reusing its data and behaviour and adding or changing what it needs. It models "is-a": a Dog is an Animal. Declare it with a colon — a class inherits exactly one base.

class Animal
{
    public string Name;
    public void Eat() => Console.WriteLine($"{Name} eats");
}

class Dog : Animal          // Dog is an Animal, plus more
{
    public void Bark() => Console.WriteLine("Woof");
}

A derived class inherits public, protected and internal members — but not private ones or constructors (though it can call them).

base refers to the parent — use it to call the base constructor, or to invoke behaviour you're extending rather than fully replacing.

class Boss : Enemy
{
    public Boss(string name) : base(name) { }   // call Enemy's constructor

    public override void Attack()
    {
        base.Attack();                           // the normal attack...
        Console.WriteLine("...then a special move!");
    }
}

We met string early as "text". Its real nature: a reference type whose data lives on the heap — yet immutable, so once created the characters never change. Operations that seem to modify a string actually return a new one.

string s = "hello";
s.ToUpper();      // returns "HELLO" but s is unchanged
s = s.ToUpper();  // reassign to keep the result

Immutability is why a string feels like a value: you can share one freely, certain no one will alter it underneath you.

Even correct code meets bad input, missing files and broken connections. An exception is an object representing a runtime error: code throws one, and unless it's caught, it stops the program.

int[] a = { 1, 2, 3 };
Console.WriteLine(a[10]);   // throws IndexOutOfRangeException

Wrap risky code in try, handle failures in catch, and put cleanup that must always run in finally.

try
{
    int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Can't divide by zero");
}
finally
{
    Console.WriteLine("This always runs");
}

• NullReferenceException — using something that's null.
• IndexOutOfRangeException — an array index past the end.
• DivideByZeroException — integer division by zero.
• FormatException — parsing text that isn't the expected format.
• ArgumentException — a method got an invalid argument.

You now have the whole C# language under your belt: the types, the control flow, the objects and the memory model. That's the foundation everything in Unity is built on.

From here, the same C# you've written all week becomes game behaviour — scripts attached to objects in a scene, reacting frame by frame. Next module: the Unity engine itself.