Rig.TUnit

Use when adding caching to .NET APIs or optimizing response times with distributed cache, output cache, or ETags.

Use when configuring API response formats, custom formatters, or Accept header handling.

Use when building controller-based REST APIs with action results, model binding, or MediatR integration.

Use when creating RESTful API controllers with MediatR dispatch and ProblemDetails error responses.

Use when designing gRPC services, proto files, or adding gRPC-Web or JSON transcoding.

Use when building minimal API endpoints with route groups, filters, or TypedResults.

Use when setting up OpenAPI spec generation or Scalar API documentation UI.

Use when adding rate limiting or throttling to .NET API endpoints.

Use when configuring Scalar API documentation UI for a .NET project.

Use when adding real-time communication with SignalR hubs, WebSocket connections, or push notifications.

Use when adding API versioning or managing multiple API versions in a .NET project.

Use when choosing between architecture patterns (VSA, Clean Architecture, DDD, Modular Monolith, Microservices) for a new project.

Use when implementing or enforcing Clean Architecture with 4-layer separation and dependency inversion.

Use when implementing CQRS with separate read/write models and MediatR pipeline behaviors.

Use when modeling domain logic with aggregates, value objects, domain events, or bounded contexts.

Use when structuring a modular monolith with module isolation and inter-module communication.

Use when adding multi-tenant support with tenant isolation, per-tenant databases, or query filters.

Use when implementing Vertical Slice Architecture with feature folders and co-located code.

Use when writing async code, propagating CancellationTokens, or fixing async/await pitfalls.

Use when applying or enforcing C# coding style — namespaces, sealed classes, var usage, XML docs.

Use when setting up IConfiguration, Options pattern, appsettings layering, or user secrets.

Use when applying modern C# idioms — records, pattern matching, primary constructors, collection expressions.

Use when registering services, choosing lifetimes, or implementing DI patterns like decorator or keyed services.

Use when selecting or implementing design patterns in C# — factory, builder, strategy, decorator, or mediator.

Use when implementing error handling with domain exceptions, ProblemDetails, or RpcException mapping.

Use when adding FluentValidation validators, custom rules, or async validation to a .NET project.

Use when applying functional patterns in C# — Result types, railway-oriented programming, or immutability.

Use when mapping between DTOs and domain objects — manual mapping, LINQ projections, or AutoMapper.

Use when adopting C# 12/13/14 features — primary constructors, collection expressions, or field keyword.

Use when evaluating code against SOLID principles or deciding when to apply or skip them.

Use when creating a new CQRS command with handler and FluentValidation validator.

Use when implementing MediatR request handlers, notification handlers, or command/query dispatch.

Use when dispatching domain events via MediatR notifications with multiple handlers.

Use when adding cross-cutting MediatR pipeline behaviors for validation, logging, or transactions.

Use when creating a new CQRS query with handler, response DTO, and pagination support.

Use when designing CQRS request/response contracts with FluentValidation and Result types.

Use when adding automatic audit trail (CreatedAt, UpdatedBy) via EF Core interceptors.

Use when writing read-optimized queries with Dapper alongside EF Core.

Use when managing database transactions, isolation levels, or cross-context coordination.

Use when configuring EF Core DbContext, entity configuration, or connection resiliency.