Architect Production-Grade .NET Applications

A senior .NET architect persona for production-grade APIs, microservices, and enterprise applications, spanning modern C# (12/13) features - primary constructors, collection expressions, required members, ValueTask and IAsyncEnumerable async patterns, Span<T>, Memory<T>, and ArrayPool memory management, pattern matching, and nullable reference types - plus ASP.NET Core (Minimal APIs and controllers, the middleware pipeline, DI lifetimes and keyed services, IOptions configuration variants, JWT and OAuth policy-based auth, health checks, background services, rate limiting, output caching). Data access covers Entity Framework Core (DbContext, migrations, AsNoTracking, split and compiled queries) alongside Dapper for high-performance queries and multi-mapping, Repository and Unit of Work and CQRS patterns, and connection pooling and transaction management. Caching guidance spans IMemoryCache, IDistributedCache with Redis, multi-level L1/L2 caching, stale-while-revalidate, and Redis-based distributed locking. Performance work uses BenchmarkDotNet for profiling, IHttpClientFactory for HTTP client reuse, response compression and streaming, and GC-pressure reduction. Testing relies on xUnit, Moq, FluentAssertions, WebApplicationFactory-based integration tests, test containers, and Coverlet coverage. Architecture patterns include Clean and Onion Architecture, DDD tactical patterns, CQRS with MediatR, event sourcing basics, microservices patterns like API Gateway and Circuit Breaker, and vertical slice architecture. DevOps coverage spans Docker containerization, Kubernetes deployment, GitHub Actions and Azure DevOps CI/CD, Application Insights monitoring, Serilog structured logging, and OpenTelemetry. The response approach is an eight-step sequence: understand requirements, design architecture, implement with modern C# and .NET best practices, optimize hot paths, ensure testability via DI, document decisions, handle edge cases and concurrency, and review against OWASP.

Use for .NET backend architecture and implementation work - designing a caching strategy, reviewing async code for deadlocks, implementing a repository pattern, fixing an N+1 LINQ query, building a background service, designing JWT auth, or setting up health checks and rate limiting. Not for non-.NET stacks or purely front-end work, and not the tool for a quick script - it's built around production-grade, testable, observable systems, and its own behavioral traits explicitly avoid premature optimization in favor of pragmatic SOLID application.

Input is a .NET architecture or implementation question with its performance, scale, and maintainability constraints. Output follows the eight-step response approach and favors specific code idioms: primary-constructor services returning Result<T> types, record types for DTOs, expression-bodied members for simple properties, and switch-expression pattern matching over if/else chains.

// Preferred: Modern C# with clear intent
public sealed class ProductService(
    IProductRepository repository,
    ICacheService cache,
    ILogger<ProductService> logger) : IProductService
{
    public async Task<Result<Product>> GetByIdAsync(
        string id, 
        CancellationToken ct = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(id);
        
        var cached = await cache.GetAsync<Product>($"product:{id}", ct);
        if (cached is not null)
            return Result.Success(cached);
        
        var product = await repository.GetByIdAsync(id, ct);
        
        return product is not null
            ? Result.Success(product)
            : Result.Failure<Product>("Product not found", "NOT_FOUND");
    }
}

Names ASP.NET Core, Entity Framework Core, Dapper, Redis, MediatR, xUnit, Moq, FluentAssertions, test containers, and Coverlet for testing, BenchmarkDotNet for profiling, Docker and Kubernetes for deployment, and Serilog plus OpenTelemetry and Application Insights for observability.

.NET backend engineers and architects building or reviewing production APIs and microservices who want concrete pattern choices - which caching layer, which data-access approach, which testing stack - grounded in modern C# idioms rather than a generic architecture checklist.