C# Advanced Course

Lesson 1 • Modern C# Syntax Essentials

Introduces pattern matching basics, records, init-only properties, and top-level statements. Ensures fluency with contemporary C# idioms used in all later examples.

Lesson 2 • Memory Management and Garbage Collection

Explains the .NET GC generations, finalization, and the IDisposable pattern. Prepares learners to write resource-safe code throughout the course.

Lesson 3 • Object-Oriented Principles in C#

Examines inheritance, polymorphism, encapsulation, and abstraction in C# syntax. Provides the OOP foundation that advanced patterns and generics chapters depend on.

Lesson 1 • Covariance and Contravariance

Explains out and in variance annotations on generic interfaces and delegates. Enables safe assignment compatibility between related generic types.

Lesson 2 • Generic Collections and Algorithms

Surveys List, Dictionary, HashSet, and immutable collection types with generic algorithms. Connects generic theory to everyday data-structure usage.

Lesson 3 • Generic Types and Methods

Defines generic classes, structs, interfaces, and methods with type parameters. Builds the vocabulary for all constraint and variance topics that follow.

Lesson 1 • Lambda Expressions and Closures

Explains lambda syntax, captured variables, closure semantics, and common pitfalls. Directly enables LINQ and functional composition covered in later sections.

Lesson 2 • Functional Composition Techniques

Introduces currying, partial application, pipeline patterns, and expression trees as data. Prepares learners for advanced LINQ and metaprogramming topics ahead.

Lesson 3 • Events and the Observer Pattern

Teaches event declaration, EventHandler conventions, custom event accessors, and thread safety. Connects delegate mechanics to the standard .NET event model.

Lesson 1 • Core LINQ Operators

Surveys filtering, projection, ordering, grouping, joining, and aggregation operators. Provides the operator vocabulary used in every real-world LINQ query.

Lesson 2 • IQueryable and Expression Trees

Explains how IQueryable translates LINQ to remote queries via expression trees. Bridges in-memory LINQ to ORM and remote data-source scenarios.

Lesson 3 • Custom LINQ Operators and Optimisation

Teaches writing custom extension methods, lazy sequences, and avoiding N+1 patterns. Completes LINQ mastery with performance-aware query design.

Lesson 1 • Advanced Async Patterns

Teaches async streams, IAsyncEnumerable, parallel async fan-out, and async initialisation. Extends async skills to streaming and concurrent scenarios.

Lesson 2 • async and await Mechanics

Explains compiler-generated state machines, SynchronizationContext, and ConfigureAwait. Enables correct async code in UI, ASP.NET, and library contexts.

Lesson 3 • Task-Based Asynchronous Pattern

Introduces Task, Task<T>, and the TAP contract including status, continuation, and exceptions. Provides the foundation for all async/await mechanics that follow.

Lesson 1 • Synchronisation Primitives

Examines lock, Monitor, Mutex, Semaphore, ReaderWriterLockSlim, and Interlocked. Provides the tools to prevent data races and coordinate shared-state access.

Lesson 2 • Task Parallel Library and PLINQ

Teaches Parallel.For, Parallel.ForEach, PLINQ, and data-parallelism partitioning strategies. Enables efficient CPU-bound workload distribution across cores.

Lesson 3 • Threading Fundamentals

Covers Thread creation, ThreadPool, thread lifecycle, and thread-local storage. Establishes the low-level threading model that higher abstractions are built upon.

Lesson 4 • Concurrent Collections

Surveys ConcurrentDictionary, ConcurrentQueue, ConcurrentBag, and BlockingCollection. Replaces manual locking with purpose-built thread-safe data structures.

Lesson 1 • Reflection API Fundamentals

Covers Assembly, Type, MethodInfo, PropertyInfo, and dynamic member invocation. Provides the runtime introspection tools used in frameworks and serialisers.

Lesson 2 • Dynamic Code with Expression Trees

Builds on earlier expression tree knowledge to compile delegates at runtime for high performance. Bridges reflection's flexibility with near-native execution speed.

Lesson 3 • Source Generators

Introduces Roslyn-based incremental source generators, syntax receivers, and generated partial classes. Shifts metaprogramming from runtime to compile time for zero-overhead abstractions.

Lesson 1 • Profiling and Benchmarking

Applies BenchmarkDotNet, memory profilers, and ETW traces to measure and validate optimisations. Closes the performance chapter with a rigorous measurement-driven workflow.

Lesson 2 • Unsafe Code and Pointers

Teaches the unsafe keyword, fixed statements, pointer arithmetic, and unmanaged memory. Enables interop with native libraries and maximum-performance inner loops.

Lesson 3 • Span<T> and Memory<T>

Covers Span<T> as a stack-only slice, Memory<T> for async contexts, and MemoryPool<T>. Enables zero-copy buffer manipulation across parsing and I/O scenarios.