Optimus Agency | Professional Web Development

Chapter 1 — Foundations10 lessons

Hello World → top-level statements → variables → I/O → conversion → operators → strings → errors → Addition Calculator

Step 1
Hello, World — your first C# program
Every language has its tradition: the first program you write prints "Hello, World" to the screen. In C# this single lin…
Start lesson
Step 2
using directives, namespaces, and comments
The .NET Base Class Library is huge. Thousands of types live inside it — Console, Math, DateTime, File, Random, List, Di…
Start lesson
Step 3
Variables and the string type
A variable is a named slot in memory that holds a value. Once you've named the slot, you can read the value, change it, …
Start lesson
Step 4
Console input — talking to the user
So far our programs have been monologues — we print, the user reads. A program that takes input is a conversation. C# gi…
Start lesson
Step 5
Numeric types — int, double, decimal, char
Strings are great for text, but most programs eventually have to count, measure, or calculate. C# gives you a precise me…
Start lesson
Step 6
Type conversion — cast, Parse, Convert, TryParse
C# is strict about types. You can't assign a double to an int by accident, and you can't add a string to a number. That …
Start lesson
Step 7
Operators, math, and the order of evaluation
Arithmetic in C# uses the same operators you've seen since school: + (plus), - (minus), * (times), / (divide), and % (mo…
Start lesson
Step 8
String formatting — interpolation, escapes, raw strings
We've already met the workhorse — interpolation: $"Hello, {name}!". You can do more than splice variables. Anything insi…
Start lesson
Step 9
Compile-time vs runtime errors
C# code has to pass through two gates before it does anything useful. The first gate is the compiler — it checks that yo…
Start lesson
Step 10
Capstone — the Addition Calculator
Time to combine the chapter. The Addition Calculator is a small program that reads two numbers from the user, validates …
Start lesson

Chapter 2 — Control Flow & Decisions10 lessons

booleans → if/else → logical operators → else-if chains → nested + scope → ternary → switch → switch expressions → string-driven decisions → Quiz App

Chapter 3 — Loops & Arrays10 lessons

loops overview → for → while → do-while → break/continue → arrays intro → iterating (for/foreach) → multidimensional → jagged → Rocket Launch simulator

Chapter 4 — Methods10 lessons

methods intro → void/return → parameters → multi-params → overloading → defaults + named args → ref/out/in → expression-bodied (=>) → recursion → Weather Simulator

Chapter 5 — Classes & Objects10 lessons

classes intro → fields → constructors → properties (auto/full/computed) → instance methods → access modifiers → readonly/const/init → static members → constructor chaining → BankAccount

Chapter 6 — Inheritance & Polymorphism10 lessons

inheritance intro (IS-A) → base/derived + protected → virtual/override → base keyword → abstract classes → constructor chains : base(...) → sealed → interfaces → polymorphism → Shape Zoo

Chapter 7 — Collections10 lessons

collections intro → List<T> basics → Contains/Sort/Reverse → lambdas + predicates → LINQ Where/Any/Select → Dictionary<K,V> → ContainsKey/TryGetValue → HashSet<T> → tuples + deconstruction → Inventory Tracker

Chapter 8 — Exceptions10 lessons

exceptions intro → try/catch basics → multiple catch + filters → finally → throwing + rethrow → built-in types → custom exceptions → best practices → using + IDisposable → Resource Pool

Chapter 9 — Generics in Depth10 lessons

generics intro → generic class Box<T> → generic methods + inference → multi type parameters → where constraints → generic interfaces → IEnumerable/ICollection/IList hierarchy → Action/Func/Predicate → default(T) + variance → Typed Bag

Chapter 10 — Delegates & Events10 lessons

delegates intro → instances + lambda assignment → multicast +=/-= + invocation list → delegates as parameters → events keyword + publisher/subscriber → EventHandler<T> + custom EventArgs → safe firing (?.Invoke + thread copy) → event vs delegate field → observer pattern → Stock Monitor

Chapter 11 — Regular Expressions10 lessons

regex intro → literals + anchors (^, $, \b) → character classes (\d \w \s + brackets) → quantifiers (* + ? {n,m} + lazy) → groups + alternation → named groups + backreferences → Regex class (IsMatch/Match/Matches + options) → Replace/Split + MatchEvaluator → lookarounds (?=, ?!, ?<=, ?<!) → Log Parser

Chapter 12 — Asynchronous Programming10 lessons

async intro → Task + Task<T> → async/await keywords → continuations + state machine → Task.WhenAll / WhenAny → async exceptions → CancellationToken → Task.FromResult + CompletedTask → async pitfalls (async void, deadlocks) → Download Aggregator

Chapter 13 — Structs, Enums & Records10 lessons

value vs reference types → defining a struct → struct vs class (mutable-struct trap) → enums → [Flags] enums → readonly/immutable structs → records (value equality) → with-expressions + deconstruction → record/class/struct decision matrix → Vector2D capstone

Chapter 14 — Dates, Times & Durations10 lessons

DateTime (ticks + Kind) → Now/Today/UtcNow + constructors → components (DayOfWeek/DayOfYear) → TimeSpan (component vs Total) → arithmetic (Add*, date − date) → formatting (InvariantCulture) → parsing (Parse/TryParse/ParseExact) → comparison + sorting → DateTimeOffset & UTC → Event Scheduler

Chapter 16 — Text, JSON & Streams10 lessons

StringBuilder (append/insert, no copies) → Split/Join/Substring/Pad string surgery → StringReader/StringWriter (TextReader/TextWriter) → JSON serialize (System.Text.Json) → Deserialize<T> + case-insensitive → JsonSerializerOptions (camelCase, indented, ignore nulls) → JsonDocument/JsonElement DOM → manual CSV parse + build → MemoryStream + UTF-8 encoding (bytes↔text) → JSON config & order processor capstone

LINQ in Depth10 lessons

Query, project, group, join, and aggregate any collection — and master deferred execution.

Threading & Concurrency10 lessons

Run code in parallel without corrupting your data: threads, locks, Interlocked, Tasks, Parallel loops, concurrent collections, coordination primitives, and producer/consumer pipelines.

Modern C# & Pattern Matching10 lessons

Nullable reference types, the null operators, and the full pattern-matching toolkit — type, property, relational, logical, tuple, list, and positional patterns — culminating in a pattern-driven command interpreter.

Testing & TDD10 lessons

Build a hand-rolled assertion harness, learn Arrange-Act-Assert and the red-green-refactor cycle, test edge cases and exceptions, isolate units with test doubles, and finish by TDD-ing a Roman-numeral converter behind a mini test runner that tallies the results.

Clean Code & SOLID10 lessons

Refactor smelly code into clean, flexible designs — guard clauses, Extract Method, and the five SOLID principles, all behaviour-preserving.

Algorithms & Big-O10 lessons

Measure how code scales: Big-O growth rates, searching and sorting, recursion and memoization, data-structure trade-offs, and time-vs-space — capped by a two-sum workshop comparing naive O(n^2) to optimal O(n).

Memory, Spans & Performance10 lessons

Stack vs heap, the generational GC, IDisposable, boxing, Span<T>, stackalloc, string allocations, and measuring your way to allocation-light code.

Reflection, Attributes & Metadata10 lessons

Inspect types at runtime, construct and invoke members dynamically, design custom attributes, and build attribute-driven engines — then make them fast with caching.

Iterators, yield & Custom Sequences10 lessons

Master lazy evaluation: build sequences with yield, compose LINQ-like operators, stream asynchronously, and dodge the deferred-execution traps.

Functional C#10 lessons

Pure functions, first-class lambdas, composition, immutability, Result/Option, pattern matching, and LINQ as a functional toolkit.

Equality, Comparison & Ordering10 lessons

Take control of what 'the same' and 'comes first' mean: ==, Equals/GetHashCode, IEquatable, IComparable, comparers, record equality, and the pitfalls that bite.

Globalization, Culture & Formatting10 lessons

CultureInfo, number/date/currency format strings, culture-aware parsing and string operations, IFormattable, and the always-InvariantCulture-for-machine-data rule.

Numbers & Math10 lessons

Integer ranges and silent overflow, checked vs unchecked, floating-point reality, decimal money, rounding strategies, the Math class, bit operations, BigInteger, and robust parsing.

Collections in Depth10 lessons

Beyond List and Dictionary: stacks, queues, linked lists, sorted and priority collections, read-only views, immutability, and how to choose the right container.

Design Patterns in C#10 lessons

The classic Gang of Four patterns retold in idiomatic modern C#: Strategy, Factory, Builder, Singleton, Observer, Decorator, Adapter, and Command — with Func/Action over interface ceremony, and the wisdom to know when NOT to use them.

Parsing & a Mini Interpreter10 lessons

Build a working expression interpreter — tokenizer, recursive-descent parser, AST, and a variable-aware calculator language.

Advanced Generics10 lessons

Variance, advanced constraints, generic math (INumber<T>), static abstract members, and IParsable<T> — the deep machinery behind reusable, type-safe code.

Chapter 33 — State Machines & Workflows10 lessons

what an FSM is (states/events/transitions) → enum + switch transition function → data-driven Dictionary<(State,Event),State> tables → guarded transitions + side-effect actions → rejecting illegal events → states as a sealed record hierarchy → entry/exit hooks + transition logging → hierarchical states + history → FSM pitfalls (state explosion, boolean soup, missing transitions) → order workflow engine capstone

Domain Modeling10 lessons

Model the domain with types so illegal states are unrepresentable

Chapter 35 — Web APIs with ASP.NET Core10 lessons

the request pipeline → Minimal APIs → routing & parameter binding → dependency injection & service lifetimes → middleware → model binding & validation → controllers vs minimal → status codes, results & ProblemDetails → configuration & auth basics → Catalog Web API capstone

Chapter 36 — Entity Framework Core10 lessons

what an ORM is → DbContext & entities → configuring the model (annotations vs Fluent API) → migrations → querying with LINQ (IQueryable → SQL) → CRUD & the change tracker → relationships → loading related data (Include / N+1) → tracking & performance → data-model capstone

Chapter 37 — Cloud & Distributed C#10 lessons

the Generic Host → configuration & the Options pattern → logging (ILogger) → background services → IHttpClientFactory → resilience (retries, circuit breaker, timeout) → gRPC → real-time SignalR → messaging & queues → resilient worker service capstone

Chapter 38 — Interactive Web UI with Blazor10 lessons

what Blazor is → Razor components → data binding (@bind) → event handling (EventCallback) → component lifecycle → rendering & state → forms & validation → render models (Server / WebAssembly / Auto) → JavaScript interop → interactive component capstone

Chapter 39 — Desktop Apps with WPF & MVVM10 lessons

what WPF is → XAML fundamentals → layout panels → controls & the content model → dependency properties → data binding + INotifyPropertyChanged → the MVVM pattern → ICommand / RelayCommand → ObservableCollection & templates → MVVM app capstone

Chapter 40 — Game Development with Unity & C#10 lessons

what Unity is → the MonoBehaviour lifecycle → GameObjects & components → vectors & transforms → input handling → physics & collisions → prefabs & instantiation → Time.deltaTime & movement → game state & UI → arcade-game capstone

Master C# from the ground up

Hello, World — your first C# program

using directives, namespaces, and comments

Variables and the string type

Console input — talking to the user

Numeric types — int, double, decimal, char

Type conversion — cast, Parse, Convert, TryParse

Operators, math, and the order of evaluation

String formatting — interpolation, escapes, raw strings

Compile-time vs runtime errors

Capstone — the Addition Calculator

Booleans and comparison operators

if and else — choosing a path

Logical operators — AND, OR, NOT

else if — multi-branch decisions

Nested conditions and variable scope

The ternary operator — one-line conditionals

The switch statement — discrete cases

Switch expressions — C# 8's cleaner form

String methods that drive decisions

Capstone — the Little Quiz App

Why loops exist — the four flavors in C#

The for loop — counting with intent

while loops — condition-driven iteration

do-while — run first, ask later

break and continue — escape hatches

Arrays — fixed-size collections of one type

Walking an array — for, foreach, and Length

Multidimensional arrays — grids in one block

Jagged arrays — arrays of arrays

Capstone — the Rocket Launch simulator

Methods — naming a piece of work

Return types — void vs producing a value

Parameters — passing data into methods

Multiple parameters — order and types matter

Method overloading — same name, different signatures

Default values and named arguments

ref, out, in — explicit parameter passing

Expression-bodied members — the => shortcut

Recursion — methods that call themselves

Capstone — the Weather Simulator

Classes & objects — the noun in OOP

Fields — the state each object carries

Constructors — building a valid instance

Properties — fields with manners

Methods on a class — behaviour bound to state

public, private, protected, internal — who can touch what

readonly, const, init — locking down values

static — class-level state and helpers

Multiple constructors — overloading and chaining

Capstone — the BankAccount class

Inheritance — building on what you already have

Base and derived — what gets inherited

virtual and override — polymorphic methods

base — extending, not replacing

abstract classes — bases you can't instantiate

Constructor inheritance — : base(args)

sealed — closing the hierarchy

Interfaces — contracts without implementation

Polymorphism — one shape, many implementations

Capstone — the Shape Zoo

Collections — beyond fixed-size arrays

List<T> — dynamic, ordered, indexable

List operations — Contains, IndexOf, Sort, Reverse

Lambdas and predicates — code as data

LINQ basics — Where, Any, Select, Count

Dictionary<K, V> — key-driven lookup

ContainsKey, TryGetValue, Remove — defensive dictionary code

HashSet<T> — unique items, fast Contains

Tuples — returning multiple values cleanly

Capstone — the Inventory Tracker

Exceptions — when something goes wrong at runtime

try / catch — handling failures gracefully

Multiple catches — handle different failures differently

finally — code that always runs

Throwing exceptions — signalling failure deliberately

The common built-in exception types

Custom exception types — speaking your domain

Exception best practices — when NOT to catch

using + IDisposable — guaranteed cleanup