Sefism .NET Developer Cheat Sheet

What this cheat sheet is

The Sefism .NET developer cheat sheet is a quick-revision companion to the .NET developer roadmap: modern C#, LINQ, async, the dotnet CLI, dependency injection, the middleware pipeline, EF Core, auth, testing and shipping. It is written for students and developers building ASP.NET Core applications, and its last chapter is a production checklist with the Program.cs code for each item.

It has 10 chapters and 78 to 79 concepts, depending on your edition: the Angular, React and Blazor editions each add one card on calling the API from that front end or on Blazor render modes. Each concept is a short card: what it is, why it matters, often a code snippet, and the mistake people usually make with it. A glossary of 63 terms covers the smaller words.

Chapter by chapter

1. C# syntax you use every day

Nine concepts: value and reference types, records, pattern matching and switch expressions, nullable reference types, primary constructors, collection expressions, generics and constraints, extension methods and extension members, and exceptions, using and finally. C# 14 ships with .NET 10; most of the chapter works from C# 9 onwards.

2. LINQ

Six concepts: Where, Select and OrderBy, deferred execution, GroupBy and aggregates, First, Single and their OrDefault versions, IEnumerable versus IQueryable, and choosing a collection.

3. async, await and Tasks

Six concepts: async and await, running work concurrently with Task.WhenAll, CancellationToken, blocking on async code, async void and IAsyncEnumerable with await foreach.

4. The dotnet CLI and the platform

Seven concepts: SDK versus runtime, LTS and STS releases, everyday dotnet commands, project types and templates, NuGet packages, the .csproj file and file-based apps.

5. Dependency injection and configuration

Seven concepts: dependency injection, transient, scoped and singleton lifetimes, the captive dependency bug, keyed services, configuration sources and their order, the options pattern and user secrets.

6. Middleware pipeline, routing and endpoints

Eight concepts: the middleware pipeline, middleware order, writing your own middleware, minimal APIs, controllers, route groups, TypedResults and status codes, and validating requests. Most "works locally, not in production" bugs start here.

7. EF Core commands and pitfalls

Ten concepts: DbContext and DbSet, migrations commands, relationships and navigation properties, Include, the N+1 query problem, tracking versus no-tracking, projecting with Select, ExecuteUpdate and ExecuteDelete, cartesian explosion and split queries, and Dapper.

8. Auth, security and the front end

ASP.NET Core Identity, JWT bearer authentication, authorization policies, CORS and OpenAPI documents, plus the edition card: calling your API from Angular or React, or Blazor render modes.

9. Testing, shipping and background work

Ten concepts: xUnit facts and theories, mocks, stubs and fakes, WebApplicationFactory, Testcontainers, containers for .NET apps, GitHub Actions, Azure App Service and Azure SQL, Key Vault with a managed identity, hosted services and BackgroundService, and Hangfire.

10. Production checklist

Ten things a production ASP.NET Core API needs, each with its Program.cs code: health checks, metrics and traces with OpenTelemetry, rate limiting with 429 responses, API versioning, structured logging, caching from memory to HybridCache and Redis, server-sent events, feature flags, exception handling with ProblemDetails, and resilience with retry, timeout, circuit breaker and fallback.

Rules of thumb

The sheet closes with ten tips, among them: target .NET 10 for new work in late 2026, since .NET 8 and .NET 9 both leave support on 10 November 2026; turn on nullable reference types and warnings as errors from the first commit; async all the way, never .Result or .Wait(); DbContext is scoped, one per request; read the SQL EF Core generates before you trust a query; secrets never go in appsettings.json; one error shape with ProblemDetails; and only retry calls that are safe to repeat, because a retried payment is a double charge.

How to use it with the roadmap

• After each stage, read the matching chapter and check you can explain every card without looking.
• While building, keep chapters 5 to 7 open: lifetimes, middleware order and EF Core traps cause most real bugs.
• Before you call a project finished, go through chapter 10 line by line against your own Program.cs.
• When you join an existing codebase, chapters 6 and 7 are the quickest way to read how it is wired.

How it works on Sefism

Everything on Sefism is free to learn from. The public cheat sheet page shows every chapter title, with the first chapters open to read. Keeping the sheet uses credits and opens every chapter in your member area; if you add the .NET developer roadmap to your dashboard, its cheat sheet comes with it, and the first roadmap you add is free. New members get starting credits, and if you have a question the sheet does not answer, you can send it to Tauseef.

Related on Sefism

• .NET documentation, ASP.NET Core documentation and Entity Framework Core documentation, the official references behind every chapter.
• Testcontainers for .NET, Polly documentation and Aspire documentation for chapters 9 and 10.
• OWASP API Security Top 10 for chapter 8.
• Related cheat sheets: Backend and SQL and databases.
• Blog: Sixteen things that break a backend

FAQ

Is this a substitute for the roadmap? No. The roadmap is the plan, with hours, milestones and one application built stage by stage; the sheet is what you revise from once you have done the work.

Which .NET version does it cover? .NET 10 and C# 14. Each production item notes the .NET version it arrived in, and all of it works on .NET 10.

What is a captive dependency? A shorter-lived service, such as a scoped DbContext, held inside a longer-lived one, such as a singleton, so it outlives its request. Chapter 5 explains how to spot and fix it.

What is the N+1 query problem? Loading a list with one query and then running one more query per item, usually through lazy navigation. Chapter 7 shows how Include or a Select projection fixes it.