C# — Intermediate
Move from C# fundamentals to building real applications: delegates, events, generics, LINQ, async, concurrency, dependency injection, HTTP, JSON, data access, testing, architecture, performance, and security — every concept practiced and graded in a sandbox running the real .NET SDK, ending in a milestone-built Task Management Engine capstone.
Who this course is for
Learners who have finished C# — Beginner (or know its material) and want to design, structure, test, debug, optimize, and build medium-sized C#/.NET applications.
What you will be able to do
- Use advanced C# type-system and language features deliberately
- Design reusable abstractions with delegates, events, generics, and LINQ
- Write async and concurrent code correctly — cancellation included
- Build layered applications with DI, configuration, HTTP, JSON, and data access
- Test, refactor, and harden code like a professional .NET developer
- Ship a milestone-built Task Management Engine capstone
The Type System Deep Dive
Value vs reference semantics, boxing, the nullable machinery, and pattern matching as an everyday design tool.
Methods & Parameters Mastery
The full parameter-passing toolbox, overload resolution as the compiler sees it, and recursion you can defend.
Delegates, Lambdas & Closures
Methods as values: the shapes, composition pipelines, capture semantics, and the bugs capture semantics cause.
Events & the Observer Pattern
The event keyword as encapsulated multicast, EventHandler contracts, custom event args, and lifetime hygiene.
Generic Design
Constraints that document requirements, generic algorithms, and covariance/contravariance without tears.
Collections & Complexity
Choosing structures by their operation costs, from Dictionary to Queue — with the Big-O to defend the choice.
Iterators & Lazy Pipelines
yield as a state machine, deferred execution you can observe, and pipelines that touch data once.
LINQ Deep Cuts
Grouping, joining, aggregating, and windowing sequences — and the execution model that decides whether it runs once or five times.
Asynchronous Programming
Tasks, async/await, fan-out with WhenAll, cancellation, timeouts, and async streams — without the classic traps.
Concurrency Fundamentals
Threads, races, locks, and atomic operations — the vocabulary of code that does several things at once, without the data corruption.
Dependency Injection
Invert dependencies behind interfaces, inject them through constructors, and wire lifetimes in one composition root.
Configuration & Options
Layer config from files and environment variables into validated, strongly-typed options — and keep secrets out of source.
HTTP & API Clients
Requests, responses, status codes, and resilient clients — deterministic hands-on with a literal HttpMessageHandler.
JSON & Serialization
System.Text.Json end to end: options, converters, malformed input, and the round-trip fidelity mindset.
Data Access Fundamentals
Connections, commands, parameters, transactions — the relational vocabulary every data layer stands on.
Testing & Mocking
Build a test framework from scratch, hand-roll test doubles, and isolate state — understand what xUnit does before you ever need it.
Clean Code & Refactoring
Name things honestly, kill nesting with guard clauses, split god methods — and refactor without changing behavior, guarded by tests.
Design Patterns in Practice
Strategy, Factory, Builder, Adapter, Decorator, Repository, Observer — each taught as a problem first, with tradeoffs and when NOT to use it.
Architecture Fundamentals
Layers, dependency direction, DTOs at boundaries, a composition root — and spotting the wrong-direction dependency that makes code untestable.
Performance Fundamentals
Where allocations actually come from, why collection choice dominates cost, how LINQ pipelines double their work — and why you measure before you touch anything.
Security Fundamentals
Where real-world C# code gets breached: string-built queries, unresolved paths, plaintext passwords, and secrets in logs — and the defensive shape for each.
Capstone: Task Management Engine
The whole course in one system: domain and validation, a repository, a service layer with authorization, reporting, persistence, and dependency wiring — built milestone by milestone.