Fifteen weeks that turn a working Python engineer into a production-ready C# and .NET engineer. We treat C# as what it is in 2026 — a modern, cross-platform, open-source language whose runtime competes head-to-head with the JVM and Go. You finish able to ship an ASP.NET Core service, a MAUI client, a Blazor admin, and a small Unity gameplay layer — and to talk about the runtime with the people who maintain it.
§ I · The Program
Crunch Sharp is the C# and .NET engineering specialization of the
Code Crunch academy — the Microsoft-stack track of the Crunch Labs
tier, authored in 2026 for engineers who want the modern .NET runtime
rather than the 2010s memory of it. It is open-source-first by
design: VS Code with the C# Dev Kit and JetBrains Rider Community
are the default editors, the dotnet CLI is the default
build tool, and the curriculum runs end-to-end on macOS and Linux.
You write ASP.NET Core 9 Minimal APIs with EF Core, Identity, JWT,
and OIDC. You ship a .NET MAUI mobile client that signs in, syncs
offline, and consumes a typed gRPC contract. You build a Blazor Auto
admin with MudBlazor. You profile hot paths with
Span<T>, ArrayPool<T>, and
Native AOT. You containerize with multi-stage Docker, you deploy
with GitHub Actions, and you write the runbook your future self will
thank you for. Visual Studio is acknowledged but never required.
"One deployable system. Three clients. One contract." — Crunch Sharp, course syllabus
§ II · Who It's For
Sharp is opinionated about its audience. C1 (Code Crunch Convos) is the floor — you should be comfortable with Python functions, classes, generators, and async before Week 1.
Shipped Flask, FastAPI, or Django at work. Wants a statically typed second language with first-class tooling. Picked C# because the runtime story is cleaner and EF Core is one of the best ORMs ever written.
Insurance, banking, healthcare, defense, and most mid-market SaaS run on .NET. Finished C1 and wants a credential that opens those doors without eight more months of saturated JavaScript bootcamps.
Writes MonoBehaviour scripts every day. Has never touched async/await, never used LINQ deliberately, never written a unit test. C9 closes the gap so you can build the server your game has always needed.
Ships a REST API in Node, Python, or Go today, and needs one mobile codebase for iOS and Android without the React Native tax. MAUI plus ASP.NET Core is the most efficient stack on the market for a small team.
§ III · Four Phases
The arc of the program is composed in four phases — building from the language and the runtime outward to a polyglot capstone with three clients sharing one contract.
The language, the runtime, and the standard library. The CLR, JIT, and GC. Modern C# — records, pattern matching, nullable refs, primary constructors. LINQ, async/await, channels, DI. By Week 4 the language feels ordinary.
ASP.NET Core 9 Minimal APIs and MVC. EF Core with PostgreSQL plus Dapper for hot queries. Identity, JWT, OIDC, resource-based authorization. SignalR, background workers, the outbox pattern, and Polly resilience.
gRPC and gRPC-Web as typed contracts. .NET MAUI for iOS, Android, macOS, and Windows. Blazor Server, WASM, and Auto with MudBlazor. Span<T>, ArrayPool<T>, BenchmarkDotNet, Native AOT, source generators, and a Unity gameplay intro.
Polyglot Workshop integration. WebApplicationFactory<T> and Testcontainers for integration tests. Serilog and OpenTelemetry for observability. Multi-stage Docker, GitHub Actions, Azure Container Apps free tier, runbook, and live demo.
§ IV · The Curriculum
Each entry corresponds to a folder in the GitHub repository with lecture notes, a lab, a reading and quiz, a mini-project, and a peer review. Detailed acceptance criteria live in the syllabus.
Value vs reference types · struct vs class · nullable reference types · record and record struct · dotnet new, build, run, test.
Ledger CLI — double-entry accounting with immutable records
Generic types and methods · where constraints · List, Dictionary, HashSet, ImmutableArray, FrozenDictionary · deferred execution · IEnumerable vs IQueryable.
Repo Stats — author-by-month commit stats over libgit2sharp
Task, ValueTask, the state machine · ConfigureAwait · CancellationToken · IAsyncEnumerable · System.Threading.Channels · deadlocks to avoid.
Crawler — bounded concurrent crawler with Channel and graceful shutdown
Classes, interfaces, primary constructors · SOLID, briefly and honestly · Microsoft.Extensions.DependencyInjection · options pattern · structured logging.
Notifier — pluggable transport library wired through MS.DI
WebApplication builder · route groups · model binding, validation, problem details · OpenAPI generation · middleware pipeline order.
Sharp Notes API — Minimal API + Razor Pages moderation
DbContext, change tracking, migrations · IQueryable translation · Dapper as a performance escape hatch · SQLite locally, PostgreSQL in production.
Sharp Notes Persistence — EF Core audit log + Dapper tag search
ASP.NET Core Identity · cookie vs JWT bearer · OIDC with Keycloak · authorization policies and requirement handlers · CSRF, CORS, secure-cookie defaults.
Sharp Notes Auth — Identity + JWT + Keycloak OIDC + RequireOwner
SignalR hubs and groups · Redis backplane · BackgroundService and queued work · the outbox pattern · Polly retry, circuit breaker, timeout, bulkhead.
Sharp Notes Live — SignalR collaboration + outbox-driven @-mentions
Protobuf and .proto codegen · unary, server-streaming, client-streaming, bidirectional · gRPC-Web for browsers · Refit for typed REST · service versioning.
Notes Contract — shared .proto + generated client library
Single-project model · XAML and MVU · CommunityToolkit.Mvvm source generators · navigation and DI · partial classes for platform code · SQLite-net-pcl.
Sharp Notes Mobile — MAUI app with OIDC, gRPC, offline-first SQLite
Blazor Server vs WASM vs Auto in .NET 9 · components, render modes, JS interop · MudBlazor and the amethyst theme · MAUI Blazor Hybrid · auth state in WASM.
Sharp Notes Admin — Blazor Auto + MudBlazor over gRPC-Web
Span<T>, Memory<T>, ref struct · ArrayPool, MemoryPool · BenchmarkDotNet · Native AOT · source generators · Unity MonoBehaviour and coroutines.
Hot Path — Span/pool rewrite + Native AOT CLI + Unity NamedPipes scene
Vertical-slice delivery · integration tests with WebApplicationFactory<T> · Testcontainers for PostgreSQL and Keycloak · Serilog · OpenTelemetry intro.
Integration baseline — three clients green in CI against one contract
Threat modeling at the API boundary · OWASP API Top 10 in .NET · MediatR for handlers · AutoMapper where it earns its keep · logs, metrics, traces, exemplars.
Production polish — auth-covered tests + Grafana / Loki / Tempo
Multi-stage Dockerfiles for ASP.NET Core and Native AOT · GitHub Actions pipelines · Azure Container Apps free tier · release notes, runbook, on-call basics.
Polyglot Workshop — live demo + runbook + portfolio review
§ V · The Toolchain
Every primary tool below is free. Visual Studio is acknowledged but never required — VS Code with the C# Dev Kit and JetBrains Rider Community are the defaults, and the curriculum runs end-to-end on macOS and Linux.
§ VI · Skills You Will Carry
By the end of Week 15, you are able to do each of the following — credibly, in a real codebase, in front of a real reviewer.
required members, primary constructors, collection expressions.ValueTask, IAsyncEnumerable, Channel<T>, and cancellation tokens — without deadlocking on .Result.List, Dictionary, FrozenDictionary, ImmutableArray — and justify it.IEnumerable and IQueryable, and know which one you are in at any given moment.BenchmarkDotNet, then optimize with Span<T>, ArrayPool<T>, and Native AOT.WebApplicationFactory<T> and Testcontainers.dotnet new to a live URL with one push — multi-stage Docker, GitHub Actions, Azure Container Apps, and a runbook.§ VII · The Capstone
Weeks 13–15 replace the weekly mini-project with capstone milestones. Architecture diagram, live deploy, integration tests, runbook. The capstone is graded on contract integrity and operability — not on visual polish.
Capstone Brief
A workshop / classroom platform built three ways from one source of truth: an ASP.NET Core 9 backend, a .NET MAUI mobile client, and a Blazor admin dashboard, all consuming a single typed gRPC contract. Instructors create lessons, learners enroll, both submit and review exercises, and an analytics surface aggregates progress.
WebApplicationFactory<T> and Testcontainers for PostgreSQL and Keycloak, plus a BenchmarkDotNet regression test on one hot path.RUNBOOK.md covering deploy, rollback, log locations, OIDC client-secret rotation, and what to do if the database fills up.§ VIII · Getting Started
Setup is intentionally lightweight. If you have a laptop that can run the .NET 9 SDK and Docker (or colima/podman), you can begin Week 1 today. No paid tooling is required at any point.
# 1. Clone the curriculum repository git clone https://github.com/CODECRUNCHWORLDWIDE/C9-CRUNCH-SHARP.git cd C9-CRUNCH-SHARP # 2. Install the .NET 9 SDK and confirm the toolchain brew install --cask dotnet-sdk # macOS sudo apt install dotnet-sdk-9.0 # Debian / Ubuntu dotnet --version # expect 9.0.x # 3. Open Week 1 README and begin $EDITOR curriculum/week-01-type-system/README.md
Prefer Rider, or need the Docker-free path? See the README.
§ IX · Frequently Asked
No. VS Code with the C# Dev Kit, or JetBrains Rider Community, is the default editor for the entire curriculum. The dotnet CLI is the default build tool. Visual Studio is acknowledged for the Windows-shop reality, but it is never required, and the course runs end-to-end on macOS and Linux.
No. Azure Container Apps free tier is the primary deploy target for the capstone because the free tier is generous, but Fly.io, Linode, Hetzner, or anywhere a Linux container runs is fully supported. You can also do the entire course locally against Docker and never touch a cloud account.
Yes — for the right reasons. C# in 2026 is a modern, statically typed, async-first language with one of the best ORMs ever written (EF Core), a clean runtime (.NET 9), and a single-codebase mobile story (MAUI) that competes with Kotlin Multiplatform and Flutter. If your goal is mid-market backend, fintech, healthcare, defense, or enterprise SaaS, C# opens doors that JavaScript bootcamps no longer reliably do.
C16 · Crunch Pro Web Backend is the Python equivalent of the same backend surface — many graduates do both to be polyglot. C17 · Crunch Pro Python Advanced is the nearest sibling for ecosystem comparison. C11 · Crunch Arcade and C12 · Crunch 3D pick up where the Week 12 Unity intro ends. C13 · Hack the Interview pairs naturally with C9 for the algorithm/system-design loop most .NET shops still run.
That is the assumed starting point. Week 1 begins at the type system, the CLR, and the JIT. No prior C# exposure is required. The only assumption is Python fluency — C1 · Code Crunch Convos is the named prerequisite.
Yes — for C#/.NET roles specifically. The closing weeks include an interview prep pack focused on the questions that actually show up: collection internals, async pitfalls, EF Core query translation, GC generations, value-vs-reference semantics, and lock-free primitives. Pair it with C13 · Hack the Interview for the algorithm side.
§ X · Begin
Open the repository. Read Week 1. The contract is yours to define.