C# Essentials

Write vs WriteLine, escape sequences, your first string interpolation, and leaving notes in your code.

Decode error messages like a pro: error codes, line numbers, the classic beginner errors, and compile-time vs runtime failures.

Name and store values: declaration syntax, reassignment, naming rules, and the var shortcut.

int, double, bool, and char — plus decimal for money and why 0.1 + 0.2 isn't quite 0.3.

The arithmetic operators, the infamous integer-division trap, the remainder operator, and compound assignment.

Moving values between types: implicit widening, explicit casts that truncate, Parse for strings, and the safe TryParse pattern.

Text in C#: Length, the everyday string methods, immutability, and the concatenation trap interpolation saves you from.

Make programs interactive: Console.ReadLine, converting typed text to numbers, and your first complete input→process→output program.

The six comparison operators, expressions that produce bools, and the crucial difference between = and ==.

Branching: if runs code conditionally, else catches the other case, and else-if chains pick one path among many.

Combine conditions with && (and), || (or), and ! (not) — plus short-circuiting and the range-check idiom.

Choosing among many exact values: the classic switch, C#'s elegant switch expression, and the one-line ternary.

The module boss fight: the empty-if semicolon, the braceless-if illusion, ordering bugs, and hand-tracing drills.

Repeat while a condition holds: loop anatomy, hand-tracing iterations, and how infinite loops happen.

The counting loop: initializer, condition, and update in one line — plus off-by-one mastery and counting down.

The run-first loop, the emergency exit, and the skip button — three tools for finer loop control.

Loops inside loops: the odometer rhythm, grids and patterns, and counting total iterations.

The five patterns behind a thousand exam questions: accumulate, count, min/max, find-first, and validate-all.

Name a block of code and reuse it anywhere: defining methods, calling them, and C#'s PascalCase convention.

Give methods inputs: parameters vs arguments, multiple inputs, scope, and the pass-by-value copy rule.

Methods that answer back: return types, capturing results, early returns, bool questions, and the => shorthand.

One name, several versions — plus the Math class toolbox and rolling dice with Random (mind the exclusive upper bound!).

Decompose a real program into methods, trace calls like an examiner, and meet optional parameters and named arguments.

One variable, many values: creating arrays, zero-based indexing, .Length, and the IndexOutOfRange crash.

for vs foreach: when you need the index, when you don't, and why foreach can't modify the array.

The exam workhorses: linear search, find-the-index, count-matching, reverse in place, and shift.

Grids: C#'s rectangular [,] arrays, GetLength for each dimension, nested-loop sweeps, and row vs column order.

Strings as character sequences: indexing, Substring's (start, LENGTH) signature, Split & Join, and building strings in loops.

The big mental model: arrays are references, aliasing, why methods CAN modify arrays, and returning arrays.

The idea that organizes all modern C#: bundling data and behavior into objects, with classes as their blueprints.

Fields and instance methods, creating objects with new, dot access, and each object's independent state.

Objects born valid: constructor syntax, this for shadowed names, multiple constructors, and the disappearing default.

C#'s signature feature: private fields, auto-properties { get; set; }, validating setters, and read-only properties.

One per class vs one per object: static fields, static methods, why Main is static, and Console/Math explained at last.

Objects follow the array rules: aliasing, methods mutating your objects, null, and the infamous NullReferenceException.

Build new classes on top of existing ones: the : syntax, inherited members, base-constructor calls, and is-a design.

Changing inherited behavior: virtual invites, override accepts, base.Method() extends — and C#'s explicitness vs Java's.

The payoff of OOP: base-type variables holding derived objects, dynamic dispatch, mixed collections, and is/as checks.

Classes that exist only to be inherited: abstract methods as mandatory blanks, and the template pattern.

Pure contracts: declaring interfaces, implementing several at once, interface-typed variables, and IComparable.

The module boss fight: what-compiles vs what-runs drills, casting rules, choose-the-design questions, and the Module 8 checklist.

The growable array: Add, Remove, Insert, Count, indexing — and when to choose List over array.

Filtering into new lists, the remove-while-iterating trap (and the backwards-loop fix), Sort, and lists of objects.

Key → value lookup: the indexer, KeyNotFoundException, ContainsKey and TryGetValue, and the counting idiom.

Uniqueness for free with HashSet<T>, what the <T> machinery really is, and choosing the right collection.

Surviving runtime errors: try/catch anatomy, specific catches first, the exception object, and finally.

Raise your own errors: throw, guard clauses in constructors and setters, choosing exception types, and the fail-fast philosophy.

Methods that call themselves: base case, recursive case, tracing the descent and unwind, and StackOverflowException.

The recurring shapes: digit problems, string reversal, Fibonacci (and why it's slow), and recursion vs loops.

Binary search and why sorted data changes everything, the built-in sorts, and a feel for algorithmic cost.

Data that survives the program: File.WriteAllText/ReadAllLines, appending, File.Exists, and parsing saved data.

Build a complete console app — classes, lists, menus, validation, and file persistence — composing all ten modules.

The course's master trap list in one place, a final gauntlet of drills, and your roadmap: Unity, ASP.NET, or desktop.