Real-World Web Development with .NET 9

Build a working REST endpoint in under 15 minutes using .NET 9 minimal APIs. Covers routing, parameter binding, and returning proper HTTP status codes.

When your API grows beyond a few endpoints, controllers give you structure. We'll build a full CRUD controller with proper content negotiation and response types.

Separate your API contracts from your domain models. Learn FluentValidation, data annotations, and how to map between entities and DTOs with Mapster.

Set up EF Core with SQL Server, create your first DbContext, and understand change tracking, lazy loading, and the query pipeline. This is the foundation for everything data-related.

Generate, customize, and apply database migrations step by step. We'll handle a real scenario where the schema changes multiple times during development.

Write efficient queries using LINQ syntax, filtering, sorting, pagination, and projection. Includes a look at what SQL EF Core actually generates using query logging.

Model one-to-one, one-to-many, and many-to-many relationships. We'll build a realistic data model for a product catalog with categories, tags, and reviews.

Implement these patterns over EF Core for testability and cleaner service code. We'll discuss when they add value and when they just add unnecessary abstraction.

Seed your database with realistic test data and handle optimistic concurrency using row versioning. Both are essential for real applications.

Identify slow queries, add composite indexes, and use compiled queries. We'll profile an API endpoint and cut response time in half with targeted changes.

Add Cosmos DB alongside your relational database for specific use cases like session storage and activity logs. Covers the EF Core provider and direct SDK usage.

Set up Identity with registration, login, password reset, and email confirmation. We'll customize the default Identity UI and integrate it with your API.

Go beyond simple role checks. Build policy-based authorization with custom requirements, handlers, and resource-based access control for real scenarios.

Issue and validate JWT tokens for stateless API authentication. Covers access tokens, refresh tokens, token rotation, and secure storage strategies.

Let users sign in with Google, GitHub, or Microsoft accounts. We'll configure external providers and merge external and local accounts safely.

Apply the right caching approach for each scenario. Covers IDistributedCache with Redis, in-memory caching, response caching, and cache invalidation patterns.

Protect your API from abuse using the built-in rate limiter middleware. Configure sliding window, token bucket, and fixed window policies per endpoint.

Build a consistent error response model with ProblemDetails. Implement exception handler middleware, custom exception types, and RFC 9457 problem details.

Add health check endpoints for databases, external services, and custom conditions. Wire them into monitoring dashboards with the health check UI.

Generate interactive API documentation using the new built-in OpenAPI support in .NET 9 and Scalar as a modern alternative to Swagger UI.

Structure your solution with clear boundaries between domain, application, infrastructure, and presentation layers. We'll refactor a flat project into a layered one.

Separate read and write operations using commands and queries. Implement MediatR for in-process messaging and add pipeline behaviors for validation and logging.

Work with entities, value objects, aggregates, and domain events. We'll model a real business domain where DDD concepts solve actual design problems.

Build a live notification system and a real-time dashboard using SignalR hubs. Covers connection management, groups, and scaling with a Redis backplane.

Run tasks outside the request pipeline: scheduled jobs, queue processors, and long-running workflows. We'll implement a background email queue processor.

Decouple services with asynchronous messaging. Set up RabbitMQ with MassTransit, implement publish/subscribe, and handle dead letter queues.

When HTTP/JSON isn't fast enough, gRPC gives you binary serialization and streaming. Build a gRPC service and consume it from both .NET and a Blazor client.

Build a data dashboard with Blazor Server components. Covers component lifecycle, parameter binding, event handling, and the SignalR circuit underneath.

Run .NET directly in the browser with WebAssembly. Build a standalone Blazor WASM app that calls your API, handles routing, and manages offline state.

Share state across components using cascading values, scoped services, and state containers. We'll also cover component libraries and JS interop when needed.

Orchestrate multiple services in local development using .NET Aspire. Set up service discovery, shared resources, and the Aspire dashboard for distributed tracing.

Before writing code, we'll define the requirements, user stories, and architecture for a real e-commerce platform. Includes database diagrams and API contract sketches.

Create the solution with separate projects for domain, application, infrastructure, API, and Blazor frontend. Configure shared settings, CI build scripts, and editor configs.

Define entities for products, orders, customers, and payments. Set up the DbContext with proper configurations, value conversions, and seed data for testing.

Build CRUD endpoints for products with filtering, sorting, pagination, and full-text search. Apply the CQRS patterns learned earlier with MediatR handlers.

Implement registration with email verification, login with JWT, password reset, and profile management. Wire it into the Blazor frontend with auth state providers.

Build the cart as a persistent entity tied to the user session. Implement address collection, shipping calculation, and an order placement workflow.

Integrate Stripe Checkout and Payment Intents for secure payment processing. Handle webhooks for payment confirmation, refunds, and failed payments.

Build an order processing pipeline with status tracking, inventory updates, and background email notifications using hosted services and Razor email templates.

Create an admin area for managing products, viewing orders, and processing refunds. Use Blazor components with MudBlazor for a functional, clean interface.

Test your business logic with xUnit, verify API endpoints with WebApplicationFactory, and mock external dependencies. Aim for meaningful coverage, not just high percentages.

Write Dockerfiles for your API and Blazor app, set up docker-compose with SQL Server and Redis, and configure multi-stage builds for smaller production images.

Deploy your application to Azure using deployment slots for zero-downtime releases. Configure environment variables, connection strings, and managed identities.

Set up Application Insights for telemetry, configure alerts, and review common production issues. We'll wrap up with guidance on continuing your .NET learning path.