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.

Stopping at a "halfway" code instead of going straight to machine code looks like extra work, but it buys two big things:

• It runs anywhere. The halfway code (CIL) is identical on Windows, Mac, and Linux. Each computer only has to handle the final step its own way, so the very same program runs everywhere without rewriting.
• It runs fast. That final step happens on your actual machine, right when the code is needed, so the result is tuned to your exact computer.

To write C#, you need two things, although in practice they often come together:

• The .NET SDK — the Software Development Kit. It holds the compiler that turns your C# into CIL, the runtime that runs it, and the standard library. Nothing builds or runs without it.
• A text editor or an IDE — where you write. A good one understands C#, flags mistakes as you type, and runs your program at the press of a button.

The good news: most editors bring the SDK along with them, so installing one often gets you both. The next slides cover the three you'll meet most.

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.

You've already run this. Now, let's look at what you did. When dotnet new console created your project, it didn't leave it blank: it wrote a single line of code for you.

That line is the traditional "Hello, World!". It's the first program you learn how to write when learning a new language.

Console.WriteLine("Hello, World!");

Hello, World!

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.

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;

People often call these "primitive types", borrowing the term from languages like Java. In C# that word is not quite accurate.

C# has no formal category called "primitive". Its simple types are really structs, full value types with methods of their own. You can write 5.ToString() or int.MaxValue; a true primitive could not do that. So "simple type" is the correct term.

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: "Roma".

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 holds a fixed-size, ordered collection of values that all share the same type, like a row of numbered boxes. Once created, its length never changes.

Arrays are reference types: the variable holds a reference to the block of elements, not the elements themselves. Copying an array variable copies the reference, so both names point to the same data.

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 for the same

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.

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.

A more advanced, modern form: the switch expression. Where the switch statement runs code, a switch expression evaluates to a value, using => arms and _ as the catch-all.

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

This 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. It also pairs naturally with pattern matching (testing types, shapes and ranges, not just equality). We look at pattern matching next.

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.

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.

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

A name is only usable within the region where it's declared; outside it, the compiler doesn't even know it exists. That's what keeps unrelated parts of a program from stepping on each other's names.

A local variable is declared inside a function and exists only while that function runs. Each call gets its own fresh copy, and it's gone when the function returns.

void Play()
{
    int score = 0;   // local to Play
    score += 10;
}                    // score ceases to exist here

A block is any region between { } — a loop body, an if, or a bare pair of braces. A variable declared inside a block is visible only within it.

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

Shadowing happens when an inner scope declares a name that already exists in an outer scope. The inner one "hides" the outer for that region. C# forbids it for local variables to prevent confusion.

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

It can occur between a field and a local, which is one reason clear names matter.