Basics
5 lessons · setup · types · operators · control flow · methods
01. Getting Started with C#
Basics · Prerequisite: none
C# is a statically-typed language built by Microsoft, used everywhere from games (Unity) and web (ASP.NET) to desktop and mobile. In this lecture you'll install the .NET 8 SDK, create a console project, and run it yourself.
02. Variables and Types
Basics · Prerequisite: previous lecture
C# is a statically-typed language — every variable has its type fixed at declaration. In this lecture you'll learn value types (int, double, bool, char...), reference types (string, object), conversion, and the var keyword.
03. Operators and Expressions
Basics · Prerequisite: previous lecture
Operators combine values to produce new ones. This lecture covers arithmetic, comparison, logical, assignment, increment/decrement, null-coalescing, ternary, and bitwise operators.
04. Control Flow
Basics · Prerequisite: previous lecture
Control program flow with branches and loops. Learn if·else·switch branching, for·while·do-while·foreach loops, and break·continue.
05. Methods
Basics · Prerequisite: previous lecture
A method is a named, reusable bundle of code. Cover parameters, return values, overloading, ref/out/in, params, and expression-bodied methods.
OOP
5 lessons · classes · properties · inheritance · polymorphism · interfaces
06. Classes and Objects
OOP · Prerequisite: methods
A class is a user-defined type that bundles data with behavior. Learn fields, methods, constructors, this, and access modifiers; then create objects with new and picture the memory model.
07. Properties and Encapsulation
OOP · Prerequisite: classes
Exposing fields raw lets anything happen. C# properties look like fields on the outside but act like methods inside — perfect for natural encapsulation.
08. Inheritance
OOP · Prerequisite: properties
Inheritance builds a new class by reusing an existing one's members. Learn base, virtual, override, sealed, and protected to express "is-a" relationships in code.
09. Polymorphism
OOP · Prerequisite: inheritance
Polymorphism is when the same call site runs different behavior depending on the actual object's type. Learn virtual/override, abstract classes, and upcasting/downcasting.
10. Interface
OOP · Prerequisite: polymorphism
Interfaces define only the promise "these methods must exist." They're the key tool for working around single inheritance, doing dependency inversion, and writing testable designs.
Collections & LINQ
4 lessons · arrays · List/Dict/HashSet · generics · LINQ
11. Array
Collections · Prerequisite: OOP
An array is the most basic collection — fixed-size storage of same-typed elements in a row. Cover 1-D, multi-dim, jagged arrays, the static Array methods, and foreach usage.
12. List · Dictionary · HashSet
Collections · Prerequisite: array
Cover three core collections from System.Collections.Generic in one lecture: variable-length List<T>, key-value Dictionary<TKey,TValue>, and the dedupe set HashSet<T>.
13. Generics
Collections · Prerequisite: collection basics
Generics let you write 'code that takes a type as a parameter.' Learn how collections like List<T> are built, and how to define your own generic classes, methods, and constraints.
14. LINQ
Collections · Prerequisite: generics
LINQ (Language Integrated Query) is C#'s powerful weapon for querying collections declaratively, SQL-style. Cover Where, Select, OrderBy, GroupBy, Aggregate, and deferred execution in one lecture.
Exceptions & I/O
3 lessons · exceptions · file I/O · strings
15. Exception Handling
Exceptions/IO · Prerequisite: OOP
Exception handling is the mechanism for dealing safely with unexpected situations. Learn try/catch/finally, throw, custom exceptions, and the using statement to write robust code.
16. File I/O
Exceptions/IO · Prerequisite: exception handling
Read and write text files with File, StreamReader, and StreamWriter; manipulate the filesystem with Path and Directory. Pair with using to release resources safely.
17. String Processing
Exceptions/IO · Prerequisite: file IO
Strings are the data type you handle most. Collect the everyday tools — interpolation, Split, Join, Replace, Substring, Trim, StringBuilder, string.Format.
Modern C#
5 lessons · delegates · async · nullable · patterns · records
18. Delegate and Lambda
Modern C# · Prerequisite: methods/OOP
Delegates and lambdas are the tools that let you pass methods as values. Cover Action, Func, Predicate, lambda bodies, closures, and events.
19. async / await
Modern C# · Prerequisite: delegate
async/await are the core keywords for non-blocking I/O. Cover Task, Task<T>, Task.WhenAll, exception handling, and cancellation in one lecture.
20. Nullable Reference Types
Modern C# · Prerequisite: OOP
NRT (Nullable Reference Types), introduced in C# 8, marks "could be null" in the type system to catch NullReferenceException at compile time.
21. Pattern Matching
Modern C# · Prerequisite: control flow/classes
Pattern matching is a powerful tool for branching by the shape of values. Cover is, switch expressions, property patterns, relational patterns, logical patterns, and tuple patterns.
22. record and init
Modern C# · Prerequisite: classes/properties
C# 9's record and init accessors are concise, safe tools for building 'unchanging value objects.' Cover the with expression, value equality, and record struct.