Right and left move between topics. Down and up move through the detail of each. Space goes through everything in order.

No language is the best at everything. Each was built for certain problems, and tends to do that job better than the rest:

• Python — highly readable, popular for scripting, data analysis, and machine learning.
• JavaScript — runs in every web browser, but it can also power servers via Node.js.
• C — manual memory management and good performance.
• Java — object-oriented, used for enterprise software and Android apps.

They differ in syntax and purpose, but share the same core ideas you are learning now.

C# reaches far beyond games. The same language and skills carry across four big domains:

Put it together and the appeal is clear: C# is safe, productive, and fast enough for demanding work like games.

• Safe by design — statically and strongly typed, so a whole class of mistakes is caught at compile time, before the program ever runs.
• No manual memory management — a garbage collector frees unused memory for you, removing crashes that haunt lower-level languages like C or C++.
• Productive — a huge standard library and fast iteration: try an idea, see it run, tweak, and repeat.
• Fast enough for real-time — performant enough for frame-by-frame gameplay, the sweet spot games need.
• Well-supported — a vast ecosystem of libraries, tools and community knowledge.

Which is exactly why Unity, the engine we'll use, chose C# as its scripting language.

Deep down, a computer's processor understands only one thing: machine code, composed by long strings of 0s and 1s. It cannot read C#. And if you saw machine code yourself, you couldn't read it either.

There is a gap.

You write in C#, but the processor speaks only machine code. Something has to translate between the two, like two people who share no language needing an interpreter.

All three compile and run your C# the same way, and all three are free while you're learning. On Windows, Visual Studio is the editor Unity installs by default. VS Code is the lighter, cross-platform option. Rider is JetBrains' full IDE, free for non-commercial use.

A comment is text the compiler ignores completely. It's there for programmers, to explain why code does something or to leave a note for later. You'll spot them throughout the code examples from here on.

// A single-line comment runs to the end of the line
Console.WriteLine("Hi"); // It can also sit after code

/* A block comment
   can span several lines */

Use comments to explain intent, not to restate the obvious. Clear code with good names usually needs few of them.

Two structural rules shape every C# program, and you just met both in "Hello, World!":

• A statement is a single instruction. It ends with a semicolon ;. That's why every line so far finishes with one.
• A block is a group of statements wrapped in curly braces { }. Methods, loops, and if clauses all attach a block of code to run. A block is also a statement itself.

{
    Console.WriteLine("First");  // A statement
    Console.WriteLine("Second"); // Another statement
}                                // The block groups them together, making a new statement

Once a variable has a value, its name stands in for that value wherever you use it; you can read it, compute with it, and reassign it. The most recent value is always the one that counts.

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

score = score + 5;        // Reassign from its own value
Console.WriteLine(score); // 15

string name = "Aria";
Console.WriteLine($"{name} has {score} points");

10
15
Aria has 15 points

A field you never assign isn't left as random memory. C# starts it at a default value decided by its type, so every field begins in a known, safe state. Each type's default:

Locals are the exception: they get no default. The compiler makes you assign a value before first use.

A variable's name is for humans first; choose one that says what it holds. Descriptive names make code read like an explanation of itself, vague ones force the reader to guess.

playerHealth
enemyCount
isGameOver

x
temp
data

Beyond clarity, C# follows naming conventions: local variables use camelCase (lowercase first word, capitalize each word after), while constants and other members use PascalCase (capitalize each word). A name cannot start with a digit or be a C# keyword.

C# is statically typed: it verifies every type at compile time, before the program runs, instead of discovering mismatches at runtime (mid-execution).

Moving this check to the compilation phase gives you four major advantages:

• Find errors immediately: If you try to do an operation on incompatible data, like strings and integers, the code will not compile, so a whole class of bugs never ships.
• Faster execution: the data types are already locked in, the runtime doesn't have to waste time looking up what the data is while the program is running.
• Predictable memory layout: each type has a known size and structure. The runtime can lay out and allocate memory for your data precisely, rather than determining it at runtime.
• Better coding tools: your code editor knows your data types ahead of time, so it can display highly accurate autocomplete.

The two main types in C# are value type (the variable holds the data itself) and reference type (the variable holds an address pointing to data that lives elsewhere). That single split shapes how data is copied, compared and stored. Language specification.

flowchart TD
    T["Types"] --> V["Value type"]
    T --> R["Reference type"]
    T --> TM["[...]"]

    V --> ST["struct"]
    V --> E["enum"]

    R --> C["class"]
    R --> I["interface"]
    R --> A["array"]
    R --> D["delegate"]
    R --> RM["[...]"]

This one idea defines everyday behaviour:

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

It comes down to one distinction: value types hold the data, reference types point to it. Hold onto that, because many behaviours in C# trace back to which side of the line a type sits on.

Because a reference type holds an address rather than the data itself, it can also point to nothing at all. That "points to nothing" value is null, and it is the default for every reference type until you assign one.

string name = null;             // Refers to nothing yet
name = "Aria";                  // Now refers to a real string
Console.WriteLine(name.Length); // 4

string other = null;
Console.WriteLine(other.Length); // NullReferenceException

Using a value through a null reference fails at run time with a NullReferenceException, one of the most common errors in C#. Testing for null first is how you guard against it.

C# bakes in a handful of simple types for the most basic kinds of data: whole numbers, decimals, single characters and true/false values. Each one comes with a convenient keyword name. Under the hood, every keyword is just a friendly alias for a type in the .NET library: int is really System.Int32.

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

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 (float or decimal).

int lives = 3;          // Integer by default
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

float gravity = -9.81;  // Error: cannot assign double to float
decimal price = 19.99;  // Error: cannot 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 has exactly two possible values: true and false. They usually come from a comparison, and they drive conditionals and loops.

bool isAlive = true;
bool hasKey = false;
bool canEnter = health > 0; // A comparison produces a bool
if (isAlive)
{
    Console.WriteLine("Keep playing");
}

A char holds a single character. It is the building block strings are made of. Its literal (the notation) uses single quotes ('A'), while a string uses double quotes ("A"). Do not mix them up.

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

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

Declare the set of names, then use them by name. Code reads like English, and printing an enum gives you the name.

enum Direction { North, East, South, West }

Direction facing = Direction.North;

Console.WriteLine(facing);

North

Each enum member is actually a number, by default an int, starting at 0 and counting up. You can set the values explicitly, or change the underlying type.

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

Here, for example, the underlying type is changed to byte, and each name has a custom value.

[Flags] marks an enum as a bit field, so combined values print as a list of member names, instead of a bare number. Assign each member a distinct power of two so the bits combine cleanly.

[Flags]
enum Toppings
{
    None     = 0,
    Cheese   = 1,
    Bacon    = 2,
    Mushroom = 4
}

Toppings order = Toppings.Cheese | Toppings.Bacon;
Console.WriteLine(order); // "Cheese, Bacon" (without [Flags]: "3")

The symbol "|" is the bitwise OR operator. It, and the rest of C#'s operators, are explained in the next section.

A string is a sequence of characters: names, dialogue, file paths, anything textual. It's written in double quotes like this: "Pisa".

Unlike the numeric and char types, string is a reference type: the variable holds a reference to the text, which lives elsewhere in memory. Yet, it behaves like a simple value, because strings are immutable: once created they never change, so you can share one freely without fear that something will change it.

Join strings with + (concatenation), or use string interpolation with $ to drop values straight into the text (far cleaner than a chain of +).

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

Inside an interpolated string, any expression put in { } is evaluated and turned into text.

Inside double quotes, a backslash starts an escape sequence for characters you can't type directly: \n (new line), \t (tab), \" (a quote), \\ (a literal backslash).

string path = "C:\\Users\\Aria";    // Each \\ is one backslash
string verbatim = @"C:\Users\Aria"; // @ : backslashes are literal
string quote = "She said \"hi\"";

A verbatim string (@"...") takes the text exactly as written, escapes and all. Ideal for Windows paths and multi-line text, where escaping every backslash gets tedious.

Strings are immutable: once created, their characters never change. Methods that look like they modify a string actually return a new one and leave the original untouched.

string s = "hello";
s.ToUpper();     // Returns "HELLO", but s is still "hello"
s = s.ToUpper(); // Reassign to actually keep the result

This is exactly what lets you pass a string around safely: nobody you share it with can change it on you.

Because a string can be any length, its characters live elsewhere in memory and the variable holds a reference to them. Immutability is what makes that safe to share, but it has a cost.

Since every "change" produces a new string, building text by repeatedly concatenating with + in a loop creates a pile of throwaway strings the runtime must later clean up.

Strings carry a rich toolkit. Each returns a new string or a value, never modifying the original:

• Length — number of characters; index with s[0] to read one char.
• ToUpper / ToLower — change case.
• Trim — remove surrounding whitespace.
• Substring — extract part of it.
• Replace, Split, Contains, IndexOf — search and transform.

Equality compares text, not identity: "hi" == "hi" is true, because string customises (overloads) == to compare characters.

An array type is the element type followed by []: int[], string[]. To make one, either ask for a size (slots filled with the type's default), or list the values and let C# count them.

int[] a = new int[5];            // Five slots, all 0
int[] b = new int[] { 1, 2, 3 }; // Sized from the values
int[] c = { 10, 20, 30 };        // Shorthand

new int[5] reserves five slots and fills them with 0 (the default for int). The { ... } form skips new entirely, the length comes from how many values you wrote.

The new keyword in new int[5] creates the array, reserving a block of memory for its elements and handing back a reference to it (arrays are reference types).

int[] a = new int[5]; // new builds the array, a refers to it
int[] b = { 1, 2, 3 }; // Shorthand, here new is implied

The variable and the array are two separate things: new produces the array, and the variable holds a reference to it. You will meet new constantly from here on, as it is the keyword used to create objects, which are the basis of Object Oriented Programming (OOP).

Reach an element by its index, written in [] after the variable and counting from 0. The first element is [0] and the last is [Length - 1]. Going out of range throws an exception at run time.

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

A multidimensional array (also called a rectangular array) is a single array with two or more dimensions. It uses one set of brackets with commas [,] and is accessed with multiple indices. Every dimension has a fixed length, which is what makes it "rectangular."

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

// Initialize with values directly
int[,] board = { { 1, 2 }, { 3, 4 } };

// Read dimensions
int rows = grid.GetLength(0); // 2
int cols = grid.GetLength(1); // 3

All elements occupy one contiguous block of memory, making rectangular arrays compact and efficient for evenly shaped data.

A jagged array is an array whose elements are themselves arrays, an "array of arrays." Each element array can be a different length, hence the jagged edge. It uses multiple sets of brackets [][] and is accessed one index at a time.

int[][] jagged = new int[3][]; // 3 rows, lengths set later
jagged[0] = new int[] { 1, 2 };
jagged[1] = new int[] { 3, 4, 5 };
jagged[2] = new int[] { 6 };

int x = jagged[1][2]; // 5

// Initialize with values directly
int[][] data = {
    new int[] { 1, 2 },
    new int[] { 3, 4, 5 }
};

Because each row is a separate array, rows can vary in length and be built or replaced independently. Jagged arrays are often faster for row-by-row access, while rectangular arrays use memory more compactly.

An operator is a symbol that performs an action on one or more values (its operands) and produces a result. For example, 5 + 3 applies the + operator to the operands 5 and 3 to produce 8. Combining operators and operands forms an expression, a fundamental building block of computation.

• Unary, one operand: -x (negation), !ready (logical NOT).
• Binary, two operands: a + b (addition), x < y (comparison).
• Ternary, three operands: cond ? a : b (the conditional operator, of which C# has exactly one).

Just like in math, precedence decides which operator runs first (2 + 2 * 2 is 6, not 8), associativity breaks ties between operators of equal precedence, and ( ) overrides both. The families below appear in roughly the order you will use them.

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

double precise = 9.8;
int whole = (int)precise; // 9, dropped

Casting between number types truncates rather than rounding, so (int)9.8 is 9, not 10.

You will likely never write these in everyday code, but they complete the set.

• checked / unchecked: turn integer overflow checking on or off for an expression.
• delegate: the older anonymous-method form, mostly replaced by lambdas (=>).
• stackalloc: allocate a small array on the stack, as in stackalloc int[8].
• true / false: a type can define these so its values work directly in if and &&.
• & (address-of), * (indirection), -> (pointer member): pointers, only inside an unsafe block.

Languages differ in how strictly they enforce types, and that shapes how many mistakes the compiler can catch for you. In a strongly typed language, types are enforced: you cannot accidentally treat text as a number. In a weakly typed language, types bend silently, which is flexible but error-prone.

There is a separate axis. Static typing checks types at compile time, while dynamic typing checks them at run time. C# sits firmly on the strict side of both: it is strongly and statically typed.

int x = 5;
x = "hello";     // Type error
int n = 5 + "3"; // Error: no coercion

let x = 5;
x = "hello";     // fine, now a string
let n = 5 + "3"; // "53": coerced to text
let m = 5 * "3"; // 15: coerced to number

Neither result is "wrong" in JavaScript; its rules simply let unrelated types mix. C# trades that flexibility for catching the error up front.

• Fewer runtime surprises: many bugs become compile errors.
• Better tooling: autocomplete and refactoring rely on known types.
• A little more typing up front: you state your types, but gain safety in return.

Catching a type error at compile time is far cheaper than discovering it once the program is already running.

Patterns show up most in the switch expression: a modern, more advanced form of switch. Where the switch statement runs code, a switch expression evaluates to a value, using => arms and _ as the catch-all. Each arm is a pattern — the >= 90 below is a relational pattern, not a plain equality check.

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

It belongs to C#'s functional programming features, the same family as lambdas and LINQ, which favour expressions that produce values over statements that perform actions. Next we see how patterns combine to do far more than match constants.

Programs constantly need to repeat work: deal a card to each player, step over every tile on a map, keep updating a game until it ends. A loop does that for you, running a block of code (its body) over and over, each pass called an iteration.

Every loop is driven by a boolean condition, just like an if. The difference: an if runs its block at most once, while a loop keeps re-running it as long as the condition stays true.

• while — repeat while a condition holds, the most basic form.
• do-while — the same, but always run the body at least once.
• for — repeat a known number of times, with its counter built in.
• foreach — visit every item in a collection, no counter needed.

They all repeat, but each answers a different question. Pick by what you know going in:

When more than one fits, choose the one that best states your intent.

By default a loop runs its whole body every pass, then re-checks its condition at the top. Sometimes you need to steer it from the inside: bail out early, or skip the rest of a single pass. Two keywords do that, and both work in every loop (for, while, foreach):

Both are almost always guarded by an if, so they fire only in the case you care about. The next two slides show each one in action.

So far our programs have been one long run of statements. That works until it does not: the same code is present three times, and a single screen of code becomes hard to follow. Functions fix both, giving blocks of logic a name, which you can write and call wherever you need.

It is the first real tool for taming complexity, and the foundation programming is built upon.

Strictly speaking, C# has no free-floating functions: every function belongs to an object, and is called a method (we'll meet methods properly in the OOP section). For now, top-level statements let us declare local functions and call them as if they were standalone.

Console.WriteLine("Hi, Aria!");
Console.WriteLine("Hi, Ben!");

void Greet(string who)
    => Console.WriteLine($"Hi, {who}!");

Greet("Aria");
Greet("Ben");

A function's return type declares the kind of value it hands back. The return keyword sends that value to the caller and ends the function on the spot.

int Add(int a, int b)
{
    return a + b; // Hands an int back to the caller
}

int total = Add(3, 4) + Add(1, 1); // 7 + 2 = 9

Because the call becomes the value it returns, you can use it anywhere that value fits: store it, print it, or combine it in a bigger expression. Think of a returning function as a question that gives an answer.

The basic call passes values in order: Move(10, 5). But C# offers several ways to make calls clearer and more flexible. The next slides cover each:

• Named arguments — label each value at the call site.
• Optional parameters — give a default so callers can omit it.
• params — accept any number of arguments at once.
• ref / out — pass the variable itself, not just a copy.

The first three are about calling convenience; ref and out change how the argument is passed.

params lets one parameter accept any number of arguments: the compiler gathers them into an array for you, so the caller just lists values instead of building the array first. It's how methods like Console.WriteLine and string.Format take a variable number of inputs.

void Log(string tag, params string[] messages)
{
    foreach (string m in messages)
        Console.WriteLine($"[{tag}] {m}");
}

Log("INFO", "started", "loading", "ready"); // many arguments
Log("WARN", "low memory");                  // just one
Log("DEBUG");                               // none is still valid

It coexists with ordinary parameters (tag here), but with two rules: a method may have only one params parameter, and it must be the last one. Callers can pass a comma-separated list, a ready-made array, or nothing at all.

Scopes are nested: a smaller region sits inside a larger one. A name declared in a scope is visible there and in every scope inside it, but not in the code outside.

• A block { } — the smallest scope: a loop body, an if, or a bare pair of braces.
• A function — its parameters and locals are visible to every block written inside it.

Wider scopes exist too, but they belong to the Object Oriented part of C#. For now, we work with these two levels.

A name declared inside a block { } is visible only within that block, from its declaration to the closing brace. This holds for every block: an if, a loop body, or braces on their own.

if (isAlive)
{
    int bonus = 50; // Exists only inside these braces
    score += bonus;
}
// bonus is not accessible here

for (int i = 0; i < 3; i++)
{
    // i is scoped to the loop
}
// i is not accessible here

A function's parameters follow the same rule, they're locals scoped to the whole function body.

Shadowing is when an inner scope declares a name that already exists in an enclosing scope, "hiding" the outer one for that region. To prevent silent confusion, C# forbids it between locals. You can't redeclare a name an enclosing block already introduced:

int value = 10;
{
    int value = 20; // Error: value is already in scope here
}

The same applies to a loop counter or any nested block. Clashing names are a common source of bugs, and C# would rather stop you up front. Clear, distinct names avoid the problem entirely.

• Smaller scopes are safer. A name visible only where it's needed can't be misused elsewhere. Declare variables as close to their use as you can.
• Fewer name clashes. Because names are confined to their scope, unrelated parts of a program can reuse simple names like i or count without colliding.
• Easier to read. A tight scope tells the reader exactly where a variable is relevant — they never have to wonder whether it's used somewhere far away.

Scopes help you keep the program under control: they let each part of the code reason about its own names without worrying about anything else.

Starting from "what is a program", you've assembled the core of the C# language, the foundation everything else in the course builds on:

The next module, C# Intermediate, turns from writing instructions to structuring programs, centered on object-oriented programming.

• Memory — the stack, the heap, and the garbage collector that manages them.
• Classes, objects & structs — bundling data together with the code that operates on it.
• Inheritance & polymorphism — deriving new types from existing ones.
• Generics, collections & exceptions — reusable types, common data structures, and structured error handling.

Together, these complete the language, preparing the ground for Unity.