.NET Made Easy: new and updated lessons

.NET Architecture Review: Capstone Wrap-Up

2026-09-01T10:31:23+00:00

A final architecture review of the OrderFlow capstone: step back from thirteen working pieces and check the whole distributed .NET system holds together.

Structured Logging Across Services: Correlated .NET Logs

2026-09-01T10:28:53+00:00

Make one order's journey through five services readable: correlated, structured logging in a real .NET system, stage by stage through the pipeline.

Monitoring a .NET System With Business Metrics

2026-09-01T10:28:53+00:00

Go beyond auto-instrumentation: add the business metrics that tell you whether OrderFlow is healthy right now, before any customer notices a problem.

Choosing a Testing Strategy for a Real .NET Application

2026-09-01T10:28:53+00:00

Match each testing technique to what each part of OrderFlow actually risks, instead of applying one kind of test everywhere in the codebase.

Containerizing a Real .NET App: Docker Image and Probes

2026-09-01T10:28:53+00:00

Ship OrderFlow as a container image a cluster can run, restart and health-check, with one readiness endpoint covering its three real dependencies.

Performance Optimization in .NET: Profile, Fix, Verify

2026-09-01T10:28:53+00:00

Turn a slow spot on the OrderFlow dashboard into a profiled, fixed and verified improvement, starting with N+1 queries hidden in the hot path.

Production Deployment Pipeline for a .NET Application

2026-09-01T10:28:53+00:00

Take OrderFlow from a laptop to production with a deployment pipeline that enforces what each stage must prove before customers get the release.

Designing an Enterprise .NET Application: Capstone Blueprint

2026-09-01T10:28:27+00:00

Start the capstone: design OrderFlow, an order-management system in .NET, from its core entities and services to the constraints it must handle.

Clean Architecture Project in .NET: OrderFlow Capstone

2026-09-01T10:28:27+00:00

Apply Clean Architecture to a real .NET order-management API: what lives in each project, and how placing an order flows through all four layers.

Authorization Policies in a Real ASP.NET Core API

2026-09-01T10:28:27+00:00

Decide endpoint by endpoint what users may do in OrderFlow, the ASP.NET Core capstone API, with real authorization policies and resource checks.

EF Core in a Real Project: Repository and Pooling

2026-09-01T10:28:27+00:00

Wire EF Core into the OrderFlow capstone: a real repository, query optimization and connection pool sizing working together in one .NET API.

Redis Caching in a Real .NET API: Cache-Aside Pattern

2026-09-01T10:28:27+00:00

Add Redis to the OrderFlow capstone with the cache-aside pattern, and trace a price change end to end to keep cached data correct across instances.

Background Processing Pipeline With BackgroundService

2026-09-01T10:28:27+00:00

Run OrderFlow's checkout pipeline with .NET's BackgroundService: one base class, four stages, and an honest look at what this design can't survive.

Reliable Messaging With Kafka and the Outbox Pattern

2026-09-01T10:28:27+00:00

Close OrderFlow's reliability gap with the outbox pattern published through Kafka, so checkout events survive crashes and reach every consumer.

C# File-Based Apps: Run a Single .cs File With dotnet run

2026-09-01T10:02:02+00:00

Run a C# program from a single .cs file with dotnet run, with no project file needed. Learn how file-based apps work in .NET 10 and when to use them.

C# 14 Lambda Parameter Modifiers Without Types

2026-09-01T10:01:11+00:00

In C# 14, lambda parameters can use modifiers like ref and out without spelling out their types. See the before and after, and the rules.

C# 14 Partial Constructors Explained

2026-09-01T10:01:11+00:00

C# 14 lets a constructor be split into a declaring part and an implementing part, so a source generator can supply the body. How it works, with examples.

C# 14 User-Defined Compound Assignment Operators

2026-09-01T10:01:11+00:00

C# 14 lets a type define += and other compound assignment operators directly, so a += b can update in place instead of creating a new value.

What's New in C# 14: Every New Feature Explained

2026-09-01T10:00:48+00:00

A guided tour of C# 14: extension members, the field keyword, null-conditional assignment, span conversions, partial constructors and more, with examples.

C# 14 Extension Members: Extension Properties Explained

2026-09-01T10:00:48+00:00

C# 14 extension members in full: extension properties, static extension members and the extension block syntax, and what it means for extension methods.

C# 14 field Keyword: Field-Backed Properties Explained

2026-09-01T10:00:48+00:00

C# 14's field keyword lets a property add logic without declaring its own backing field. Compare auto-properties, full properties and the new style.

C# 14 Null-Conditional Assignment: ?. on the Left Side

2026-09-01T10:00:48+00:00

C# 14 lets ?. and ?[] appear on the left of an assignment, so the value is only assigned when the object isn't null. The rules, with examples.

C# 14 Span Conversions: Implicit Span Conversions

2026-09-01T10:00:48+00:00

C# 14 adds implicit conversions between arrays, Span and ReadOnlySpan, making span-based APIs easier to call. What changed and why it matters.

Database Bottlenecks in .NET: Diagnose Slow Data Access

2026-09-01T09:45:38+00:00

When a .NET app is slow because of its database: the recurring root causes, a diagnosis flow, and worked examples starting with N+1 queries.

Production Incident Analysis for .NET Applications

2026-09-01T09:45:38+00:00

Five failure modes can look identical in production. Learn a diagnostic decision tree for .NET incidents that rules causes out instead of guessing.

Debugging .NET in Production: Observe Without Pausing

2026-09-01T04:54:46+00:00

You can't pause production. Learn how to debug live .NET apps by observing without stopping them and capturing evidence for later analysis.

Finding Memory Leaks in .NET Applications

2026-09-01T04:54:46+00:00

.NET has a GC but can still leak. Learn the few patterns behind most leaks, especially event handlers, and how to follow a GC root chain to the cause.

Diagnosing High CPU in .NET Apps: A Practical Guide

2026-09-01T04:54:46+00:00

Tell healthy load from a bug when CPU hits 100%. Learn the usual suspects, a step-by-step diagnosis flow, and a real catastrophic regex backtracking case.

Diagnosing Deadlocks in Production .NET Apps

2026-09-01T04:54:46+00:00

Find a deadlock in a .NET process you can't step through: freeze the whole picture, read the threads, and tell a deadlock from thread pool starvation.

Thread Pool Starvation in .NET: Causes and Fixes

2026-09-01T04:54:46+00:00

Every request hangs, but nothing is deadlocked. Learn why the .NET thread pool grows slowly on purpose, how starvation happens, and how to fix it.

Unit Testing in C# With xUnit: A Practical Guide

2026-09-01T04:54:21+00:00

Write unit tests in C# with xUnit, and see how automated tests replace manual checking as your .NET code grows. Clear examples from the first test up.

Integration Testing in ASP.NET Core: Test the Real App

2026-09-01T04:54:21+00:00

Test the real, assembled ASP.NET Core application and catch the wiring and configuration bugs that unit tests can never see.

Mocking in C# With Moq: Mocks vs Stubs Explained

2026-09-01T04:54:21+00:00

Isolate code under test in C# with Moq. Learn the precise difference between mocks and stubs, and how depending on abstractions makes mocking possible.

Testcontainers in .NET: Test Against a Real Database

2026-09-01T04:54:21+00:00

Use Testcontainers in .NET to start a real database in Docker for your tests, instead of mocks or in-memory providers that hide real bugs.

API Testing in .NET: Test the Contract, Not Just the Logic

2026-09-01T04:54:21+00:00

Correct logic doesn't guarantee a correct API. Learn to test status codes, headers and JSON field names in .NET so contract breaks are caught early.

Performance Testing .NET APIs: Percentiles, Not Averages

2026-09-01T04:54:21+00:00

Measure .NET API performance the right way: define a target, generate realistic load, and read latency percentiles instead of misleading averages.

Load Testing .NET Applications: Find Your Breaking Point

2026-09-01T04:54:21+00:00

Load test .NET apps to find where they break before your users do: the three common shapes of load test and how to read what they tell you.

.NET Aspire Tutorial: Introduction to the AppHost

2026-09-01T04:34:36+00:00

Get started with .NET Aspire: describe your app's services and dependencies in code with an AppHost project, with orchestration and telemetry built in.

Kubernetes Health Probes for .NET: Liveness vs Readiness

2026-09-01T04:32:23+00:00

How Kubernetes calls your .NET health endpoints: liveness and readiness probes, httpGet probe configuration, and what happens when a probe fails.

Logging in Containers: Structured Logs From .NET Apps

2026-09-01T04:32:23+00:00

Containers have no log files you can tail. Learn how .NET apps should write structured logs in a container and let the platform collect and keep them.

Scaling .NET Apps Horizontally: Why Statelessness Matters

2026-09-01T04:32:23+00:00

Vertical scaling hits a ceiling. Learn horizontal, elastic scaling for .NET apps, and why statelessness is what lets you run twenty instances safely.

Cloud-Native .NET: Designing Apps for the Cloud

2026-09-01T04:32:23+00:00

Running in the cloud is not the same as being cloud-native. Learn the design principles that let .NET apps expect failure and scale with the platform.

Docker for .NET Developers: Multi-Stage Dockerfile Guide

2026-09-01T04:32:02+00:00

Containerize .NET apps with Docker: what a container really is, and how a multi-stage Dockerfile builds a small, production-ready image.

Containerize ASP.NET Core: Ports, Binding and Docker

2026-09-01T04:32:02+00:00

Why an ASP.NET Core app that works locally refuses traffic inside a container, how to bind to all interfaces, and how to build a container-ready app.

Environment Variables in .NET: The Double Underscore Rule

2026-09-01T04:32:02+00:00

Map environment variables to nested .NET configuration keys with the double underscore convention, so container and cloud settings bind correctly.

Secrets Management in .NET: Keeping Credentials Safe

2026-09-01T04:32:02+00:00

Secrets need a higher bar than ordinary configuration. Learn why, and how .NET apps load credentials from dedicated secret stores instead of config files.

Cloud Configuration in .NET: Twelve-Factor Config

2026-09-01T04:23:38+00:00

How .NET configuration changes in the cloud: no server to edit, config injected fresh on every start, and the twelve-factor app approach to settings.

Eventual Consistency and the CAP Theorem Explained

2026-09-01T04:13:41+00:00

Why distributed systems can't always show the latest write instantly, what the CAP theorem says, and how to engineer around the consistency window.

REST API Design Best Practices: The Richardson Maturity Model

2026-09-01T04:10:48+00:00

Design REST APIs other teams can rely on: the Richardson Maturity Model, resource design, and keeping a contract stable when other services depend on it.

Microservices in .NET: Benefits, Costs and Boundaries

2026-09-01T04:10:48+00:00

Microservices move complexity from your code to the network. Learn when that trade is worth it, where service boundaries come from, and what it costs.