The .NET Insider – Issue 21

Event sourcing stores every change as an immutable event instead of just the current state. This guide shows how to implement it in .NET using Marten and PostgreSQL. It covers event storage, rebuilding aggregates, and querying historical data. The approach improves traceability, auditing, and debugging, especially in distributed systems. Practical examples demonstrate how to structure events and manage state over time.

The Saga pattern helps manage long-running workflows across multiple services. This post shows how to implement it using Wolverine in .NET. It explains coordinating actions, handling failures, and ensuring consistency without distributed transactions. Wolverine simplifies orchestration with built-in messaging and state handling. A great practical guide for building reliable distributed systems.

This article explains implementing the command side of CQRS in ASP.NET Core. Commands represent intent and are handled separately from queries, improving structure and scalability. The post shows how to organize handlers, validation, and application layers. It’s a practical approach to reducing complexity in large systems.

Choosing between sync and async communication impacts scalability and reliability. This post compares both approaches, explaining trade-offs in latency, coupling, and complexity. It also shows when to use messaging systems for asynchronous workflows. A useful guide for designing microservices architecture.

This guide shows how to improve API performance using ASP.NET Core Output Cache. It covers in-memory caching and Redis for distributed scenarios. You’ll learn how to reduce repeated processing, configure policies, and handle cache invalidation. Ideal for optimizing read-heavy APIs.

This post highlights a subtle issue where nvarchar parameters in Dapper can cause implicit conversions and lead to index scans instead of seeks. This can significantly impact performance. It explains the root cause and how to avoid it. A must-know optimization tip for database-heavy applications.

This post explains how to treat database migrations as the single source of truth during modernization. It covers strategies for managing schema changes and maintaining consistency across environments. A useful guide for teams evolving legacy systems.

Large test suites can slow down CI pipelines. This article shows how to split tests into shards for parallel execution using Meziantou.ShardedTest. This reduces execution time and improves developer productivity.

This post explores efficient techniques for matching URL patterns in .NET applications. It’s useful for routing, filtering, and request handling scenarios, improving performance and flexibility.

Microsoft announced the end of support for ASP.NET Core 2.3. The post highlights risks of staying on unsupported versions and encourages upgrading to supported releases.