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/CODE-CRUNCH-WORLDWIDE/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.
§ X · Begin
Open the repository. Read Week 1. The contract is yours to define.