Dotnet Backend Patterns by @wshobson · Skillet
Dotnet Backend Patterns Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection, Entity Framework Core, Dapper, configuration, caching, and testing with xUnit. Use when developing .NET backends, reviewing C# code, or designing API architectures.
2 unscanned files in formats the scan couldn’t read Install
It’s free, and every skill you add syncs into every AI tool on your computer, instantly.
public static class ServiceCollectionExtensions
{
public static IServiceCollection AddApplicationServices (
this IServiceCollection services,
IConfiguration configuration )"Redis:Connection" ]!));
services.AddTransient<IValidator<CreateOrderRequest>, CreateOrderValidator>();
services.Configure<CatalogOptions>(configuration.GetSection("Catalog" ));
services.Configure<RedisOptions>(configuration.GetSection("Redis" ));
services.AddScoped<IPriceCalculator>(sp =>
{
var options = sp.GetRequiredService<IOptions<PricingOptions>>().Value;
return options.UseNewEngine
? sp.GetRequiredService<NewPriceCalculator>()
: sp.GetRequiredService<LegacyPriceCalculator>();
});
services.AddKeyedScoped<IPaymentProcessor, StripeProcessor>("stripe" );
services.AddKeyedScoped<IPaymentProcessor, PayPalProcessor>("paypal" );
return services;
}
}
public class CheckoutService
{
public CheckoutService (
[FromKeyedServices("stripe" )] IPaymentProcessor stripeProcessor)
3. Async/Await Patterns
public async Task<Product> GetProductAsync (string id, CancellationToken ct = default return await _repository.GetByIdAsync(id, ct);
}
public async Task<(Stock, Price)> GetStockAndPriceAsync(
string productId,
CancellationToken ct = default )
{
var stockTask = _stockService.GetAsync(productId, ct);
var priceTask = _priceService.GetAsync(productId, ct);
await Task.WhenAll(stockTask, priceTask);
return (await stockTask, await priceTask);
}
public async Task <T > LibraryMethodAsync <T >(CancellationToken ct = default )var result = await _httpClient.GetAsync(url, ct).ConfigureAwait(false );
return await result.Content.ReadFromJsonAsync<T>(ct).ConfigureAwait(false );
}
public ValueTask <Product ?> GetCachedProductAsync (string idif (_cache.TryGetValue(id, out Product? product))
return ValueTask.FromResult(product);
return new ValueTask<Product?>(GetFromDatabaseAsync(id));
}
var result = GetProductAsync(id).Result;
var result2 = GetProductAsync(id).GetAwaiter().GetResult();
public async void ProcessOrder ()await Task.Run(async () => await GetDataAsync());
4. Configuration with IOptions
public class CatalogOptions
{
public const string SectionName = "Catalog" ;
public int DefaultPageSize { get ; set ; } = 50 ;
public int MaxPageSize { get ; set ; } = 200 ;
public TimeSpan CacheDuration { get ; set ; } = TimeSpan.FromMinutes(15 );
public bool EnableEnrichment { get ; set ; } = true ;
}
public class RedisOptions
{
public const string SectionName = "Redis" ;
public string Connection { get ; set ; } = "localhost:6379" ;
public string KeyPrefix { get ; set ; } = "mcp:" ;
public int Database { get ; set ; } = 0 ;
}
{
"Catalog" : {
"DefaultPageSize" : 50 ,
"MaxPageSize" : 200 ,
"CacheDuration" : "00:15:00" ,
"EnableEnrichment" : true
},
"Redis" : {
"Connection" : "localhost:6379" ,
"KeyPrefix" : "mcp:" ,
"Database" : 0
}
}
services.Configure<CatalogOptions>(configuration.GetSection(CatalogOptions.SectionName));
services.Configure<RedisOptions>(configuration.GetSection(RedisOptions.SectionName));
public class CatalogService
{
private readonly CatalogOptions _options;
public CatalogService (IOptions<CatalogOptions> options )public class DynamicService
{
private readonly CatalogOptions _options;
public DynamicService (IOptionsSnapshot<CatalogOptions> options )public class MonitoredService
{
private CatalogOptions _options;
public MonitoredService (IOptionsMonitor<CatalogOptions> monitor )
5. Result Pattern (Avoiding Exceptions for Flow Control)
public class Result <T >
{
public bool IsSuccess { get ; }
public T? Value { get ; }
public string ? Error { get ; }
public string ? ErrorCode { get ; }
private Result (bool isSuccess, T? value , string ? error, string ? errorCodevalue ;
Error = error;
ErrorCode = errorCode;
}
public static Result<T> Success (T value )new (true , value , null , null );
public static Result<T> Failure (string error, string ? code = null new (false , default , error, code);
public Result <TNew > Map <TNew >(Func<T, TNew> mapper )public async Task <Result <TNew >> MapAsync <TNew >(Func<T, Task<TNew>> mapper )await mapper(Value!)) : Result<TNew>.Failure(Error!, ErrorCode);
}
public async Task<Result<Order>> CreateOrderAsync(CreateOrderRequest request, CancellationToken ct)
{
var validation = await _validator.ValidateAsync(request, ct);
if (!validation.IsValid)
return Result<Order>.Failure(
validation.Errors.First().ErrorMessage,
"VALIDATION_ERROR" );
var stock = await _stockService.CheckAsync(request.ProductId, request.Quantity, ct);
if (!stock.IsAvailable)
return Result<Order>.Failure(
$"Insufficient stock: {stock.Available} available, {request.Quantity} requested" ,
"INSUFFICIENT_STOCK" );
var order = await _repository.CreateAsync(request.ToEntity(), ct);
return Result<Order>.Success(order);
}
app.MapPost("/orders" , async (
CreateOrderRequest request,
IOrderService orderService,
CancellationToken ct) =>
{
var result = await orderService.CreateOrderAsync(request, ct);
return result.IsSuccess
? Results.Created($"/orders/{result.Value!.Id} " , result.Value)
: Results.BadRequest(new { error = result.Error, code = result.ErrorCode });
});
Data Access Patterns
Entity Framework Core
public class AppDbContext : DbContext
{
public DbSet<Product> Products => Set<Product>();
public DbSet<Order> Orders => Set<Order>();
protected override void OnModelCreating (ModelBuilder modelBuilder )typeof (AppDbContext).Assembly);
modelBuilder.Entity<Product>().HasQueryFilter(p => !p.IsDeleted);
}
}
public class ProductConfiguration : IEntityTypeConfiguration <Product >
{
public void Configure (EntityTypeBuilder<Product> builder )"Products" );
builder.HasKey(p => p.Id);
builder.Property(p => p.Id).HasMaxLength(40 );
builder.Property(p => p.Name).HasMaxLength(200 ).IsRequired();
builder.Property(p => p.Price).HasPrecision(18 , 2 );
builder.HasIndex(p => p.Sku).IsUnique();
builder.HasIndex(p => new { p.CategoryId, p.Name });
builder.HasMany(p => p.OrderItems)
.WithOne(oi => oi.Product)
.HasForeignKey(oi => oi.ProductId);
}
}
public class ProductRepository : IProductRepository
{
private readonly AppDbContext _context;
public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default )
{
return await _context.Products
.AsNoTracking()
.FirstOrDefaultAsync(p => p.Id == id, ct);
}
public async Task<IReadOnlyList<Product>> SearchAsync(
ProductSearchCriteria criteria,
CancellationToken ct = default )
{
var query = _context.Products.AsNoTracking();
if (!string .IsNullOrWhiteSpace(criteria.SearchTerm))
query = query.Where(p => EF.Functions.Like(p.Name, $"%{criteria.SearchTerm} %" ));
if (criteria.CategoryId.HasValue)
query = query.Where(p => p.CategoryId == criteria.CategoryId);
if (criteria.MinPrice.HasValue)
query = query.Where(p => p.Price >= criteria.MinPrice);
if (criteria.MaxPrice.HasValue)
query = query.Where(p => p.Price <= criteria.MaxPrice);
return await query
.OrderBy(p => p.Name)
.Skip((criteria.Page - 1 ) * criteria.PageSize)
.Take(criteria.PageSize)
.ToListAsync(ct);
}
}
Dapper for Performance public class DapperProductRepository : IProductRepository
{
private readonly IDbConnection _connection;
public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default )
{
const string sql = """
SELECT Id, Name, Sku, Price, CategoryId, Stock, CreatedAt
FROM Products
WHERE Id = @Id AND IsDeleted = 0
""" ;
return await _connection.QueryFirstOrDefaultAsync<Product>(
new CommandDefinition(sql, new { Id = id }, cancellationToken: ct));
}
public async Task<IReadOnlyList<Product>> SearchAsync(
ProductSearchCriteria criteria,
CancellationToken ct = default )
{
var sql = new StringBuilder("""
SELECT Id, Name, Sku, Price, CategoryId, Stock, CreatedAt
FROM Products
WHERE IsDeleted = 0
""" );
var parameters = new DynamicParameters();
if (!string .IsNullOrWhiteSpace(criteria.SearchTerm))
{
sql.Append(" AND Name LIKE @SearchTerm" );
parameters.Add("SearchTerm" , $"%{criteria.SearchTerm} %" );
}
if (criteria.CategoryId.HasValue)
{
sql.Append(" AND CategoryId = @CategoryId" );
parameters.Add("CategoryId" , criteria.CategoryId);
}
if (criteria.MinPrice.HasValue)
{
sql.Append(" AND Price >= @MinPrice" );
parameters.Add("MinPrice" , criteria.MinPrice);
}
if (criteria.MaxPrice.HasValue)
{
sql.Append(" AND Price <= @MaxPrice" );
parameters.Add("MaxPrice" , criteria.MaxPrice);
}
sql.Append(" ORDER BY Name OFFSET @Offset ROWS FETCH NEXT @PageSize ROWS ONLY" );
parameters.Add("Offset" , (criteria.Page - 1 ) * criteria.PageSize);
parameters.Add("PageSize" , criteria.PageSize);
var results = await _connection.QueryAsync<Product>(
new CommandDefinition(sql.ToString(), parameters, cancellationToken: ct));
return results.ToList();
}
public async Task<Order?> GetOrderWithItemsAsync(int orderId, CancellationToken ct = default )
{
const string sql = """
SELECT o.*, oi.*, p.*
FROM Orders o
LEFT JOIN OrderItems oi ON o.Id = oi.OrderId
LEFT JOIN Products p ON oi.ProductId = p.Id
WHERE o.Id = @OrderId
""" ;
var orderDictionary = new Dictionary<int , Order>();
await _connection.QueryAsync<Order, OrderItem, Product, Order>(
new CommandDefinition(sql, new { OrderId = orderId }, cancellationToken: ct),
(order, item, product) =>
{
if (!orderDictionary.TryGetValue(order.Id, out var existingOrder))
{
existingOrder = order;
existingOrder.Items = new List<OrderItem>();
orderDictionary.Add(order.Id, existingOrder);
}
if (item != null )
{
item.Product = product;
existingOrder.Items.Add(item);
}
return existingOrder;
},
splitOn: "Id,Id" );
return orderDictionary.Values.FirstOrDefault();
}
}
Caching Patterns
Multi-Level Cache with Redis public class CachedProductService : IProductService
{
private readonly IProductRepository _repository;
private readonly IMemoryCache _memoryCache;
private readonly IDistributedCache _distributedCache;
private readonly ILogger<CachedProductService> _logger;
private static readonly TimeSpan MemoryCacheDuration = TimeSpan.FromMinutes(1 );
private static readonly TimeSpan DistributedCacheDuration = TimeSpan.FromMinutes(15 );
public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default )
{
var cacheKey = $"product:{id} " ;
if (_memoryCache.TryGetValue(cacheKey, out Product? cached))
{
_logger.LogDebug("L1 cache hit for {CacheKey}" , cacheKey);
return cached;
}
var distributed = await _distributedCache.GetStringAsync(cacheKey, ct);
if (distributed != null )
{
_logger.LogDebug("L2 cache hit for {CacheKey}" , cacheKey);
var product = JsonSerializer.Deserialize<Product>(distributed);
_memoryCache.Set(cacheKey, product, MemoryCacheDuration);
return product;
}
_logger.LogDebug("Cache miss for {CacheKey}, fetching from database" , cacheKey);
var fromDb = await _repository.GetByIdAsync(id, ct);
if (fromDb != null )
{
var serialized = JsonSerializer.Serialize(fromDb);
await _distributedCache.SetStringAsync(
cacheKey,
serialized,
new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = DistributedCacheDuration
},
ct);
_memoryCache.Set(cacheKey, fromDb, MemoryCacheDuration);
}
return fromDb;
}
public async Task InvalidateAsync (string id, CancellationToken ct = default var cacheKey = $"product:{id} " ;
_memoryCache.Remove(cacheKey);
await _distributedCache.RemoveAsync(cacheKey, ct);
_logger.LogInformation("Invalidated cache for {CacheKey}" , cacheKey);
}
}
public class StaleWhileRevalidateCache <T >
{
private readonly IDistributedCache _cache;
private readonly TimeSpan _freshDuration;
private readonly TimeSpan _staleDuration;
public async Task<T?> GetOrCreateAsync(
string key,
Func<CancellationToken, Task<T>> factory,
CancellationToken ct = default )
{
var cached = await _cache.GetStringAsync(key, ct);
if (cached != null )
{
var entry = JsonSerializer.Deserialize<CacheEntry<T>>(cached)!;
if (entry.IsStale && !entry.IsExpired)
{
_ = Task.Run(async () =>
{
var fresh = await factory(CancellationToken.None);
await SetAsync(key, fresh, CancellationToken.None);
});
}
if (!entry.IsExpired)
return entry.Value;
}
var value = await factory(ct);
await SetAsync(key, value , ct);
return value ;
}
private record CacheEntry <TValue >(TValue Value, DateTime CreatedAt )public bool IsStale => DateTime.UtcNow - CreatedAt > _freshDuration;
public bool IsExpired => DateTime.UtcNow - CreatedAt > _staleDuration;
}
}
Testing Patterns
Unit Tests with xUnit and Moq public class OrderServiceTests
{
private readonly Mock<IOrderRepository> _mockRepository;
private readonly Mock<IStockService> _mockStockService;
private readonly Mock<IValidator<CreateOrderRequest>> _mockValidator;
private readonly OrderService _sut;
public OrderServiceTests ()new Mock<IOrderRepository>();
_mockStockService = new Mock<IStockService>();
_mockValidator = new Mock<IValidator<CreateOrderRequest>>();
_mockValidator
.Setup(v => v.ValidateAsync(It.IsAny<CreateOrderRequest>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new ValidationResult());
_sut = new OrderService(
_mockRepository.Object,
_mockStockService.Object,
_mockValidator.Object);
}
[Fact ]
public async Task CreateOrderAsync_WithValidRequest_ReturnsSuccess ()var request = new CreateOrderRequest
{
ProductId = "PROD-001" ,
Quantity = 5 ,
CustomerOrderCode = "ORD-2024-001"
};
_mockStockService
.Setup(s => s.CheckAsync("PROD-001" , 5 , It.IsAny<CancellationToken>()))
.ReturnsAsync(new StockResult { IsAvailable = true , Available = 10 });
_mockRepository
.Setup(r => r.CreateAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new Order { Id = 1 , CustomerOrderCode = "ORD-2024-001" });
var result = await _sut.CreateOrderAsync(request);
Assert.True(result.IsSuccess);
Assert.NotNull(result.Value);
Assert.Equal(1 , result.Value.Id);
_mockRepository.Verify(
r => r.CreateAsync(It.Is<Order>(o => o.CustomerOrderCode == "ORD-2024-001" ),
It.IsAny<CancellationToken>()),
Times.Once);
}
[Fact ]
public async Task CreateOrderAsync_WithInsufficientStock_ReturnsFailure ()var request = new CreateOrderRequest { ProductId = "PROD-001" , Quantity = 100 };
_mockStockService
.Setup(s => s.CheckAsync(It.IsAny<string >(), It.IsAny<int >(), It.IsAny<CancellationToken>()))
.ReturnsAsync(new StockResult { IsAvailable = false , Available = 5 });
var result = await _sut.CreateOrderAsync(request);
Assert.False(result.IsSuccess);
Assert.Equal("INSUFFICIENT_STOCK" , result.ErrorCode);
Assert.Contains("5 available" , result.Error);
_mockRepository.Verify(
r => r.CreateAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()),
Times.Never);
}
[Theory ]
[InlineData(0) ]
[InlineData(-1) ]
[InlineData(-100) ]
public async Task CreateOrderAsync_WithInvalidQuantity_ReturnsValidationError (int quantityvar request = new CreateOrderRequest { ProductId = "PROD-001" , Quantity = quantity };
_mockValidator
.Setup(v => v.ValidateAsync(request, It.IsAny<CancellationToken>()))
.ReturnsAsync(new ValidationResult(new []
{
new ValidationFailure("Quantity" , "Quantity must be greater than 0" )
}));
var result = await _sut.CreateOrderAsync(request);
Assert.False(result.IsSuccess);
Assert.Equal("VALIDATION_ERROR" , result.ErrorCode);
}
}
Integration Tests with WebApplicationFactory public class ProductsApiTests : IClassFixture <WebApplicationFactory <Program >>
{
private readonly WebApplicationFactory<Program> _factory;
private readonly HttpClient _client;
public ProductsApiTests (WebApplicationFactory<Program> factory )"TestDb" ));
services.RemoveAll<IDistributedCache>();
services.AddDistributedMemoryCache();
});
});
_client = _factory.CreateClient();
}
[Fact ]
public async Task GetProduct_WithValidId_ReturnsProduct ()using var scope = _factory.Services.CreateScope();
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.Products.Add(new Product
{
Id = "TEST-001" ,
Name = "Test Product" ,
Price = 99.99 m
});
await context.SaveChangesAsync();
var response = await _client.GetAsync("/api/products/TEST-001" );
response.EnsureSuccessStatusCode();
var product = await response.Content.ReadFromJsonAsync<Product>();
Assert.Equal("Test Product" , product!.Name);
}
[Fact ]
public async Task GetProduct_WithInvalidId_Returns404 ()var response = await _client.GetAsync("/api/products/NONEXISTENT" );
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
Best Practices
DO
Use async/await all the way through the call stackInject dependencies through constructor injectionUse IOptions for typed configurationReturn Result types instead of throwing exceptions for business logicUse CancellationToken in all async methodsPrefer Dapper for read-heavy, performance-critical queriesUse EF Core for complex domain models with change trackingCache aggressively with proper invalidation strategiesWrite unit tests for business logic, integration tests for APIsUse record types for DTOs and immutable data
DON'T
Don't block on async with .Result or .Wait()Don't use async void except for event handlersDon't catch generic Exception without re-throwing or loggingDon't hardcode configuration valuesDon't expose EF entities directly in APIs (use DTOs)Don't forget AsNoTracking() for read-only queriesDon't ignore CancellationToken parametersDon't create new HttpClient() manually (use IHttpClientFactory)Don't mix sync and async code unnecessarilyDon't skip validation at API boundaries
Common Pitfalls
N+1 Queries : Use .Include() or explicit joinsMemory Leaks : Dispose IDisposable resources, use usingDeadlocks : Don't mix sync and async, use ConfigureAwait(false) in librariesOver-fetching : Select only needed columns, use projectionsMissing Indexes : Check query plans, add indexes for common filtersTimeout Issues : Configure appropriate timeouts for HTTP clientsCache Stampede : Use distributed locks for cache population
~5.7K tokens
