dotnet-patterns

.NET 개발 패턴

강력하고 성능이 뛰어나며 유지보수 가능한 애플리케이션 구축을 위한 관용적인 C# 및 .NET 패턴입니다.

활성화 시점

• 새로운 C# 코드 작성 시
• C# 코드 검토 시
• 기존 .NET 애플리케이션 리팩터링 시
• ASP.NET Core로 서비스 아키텍처 설계 시

핵심 원칙

1. 불변성 선호

데이터 모델에는 레코드와 init 전용 속성을 사용하세요. 가변성은 명시적이고 정당한 선택이어야 합니다.

// 좋음: 불변 값 객체
public sealed record Money(decimal Amount, string Currency);

// 좋음: init setter를 사용하는 불변 DTO
public sealed class CreateOrderRequest
{
    public required string CustomerId { get; init; }
    public required IReadOnlyList<OrderItem> Items { get; init; }
}

// 나쁨: public setter를 가진 가변 모델
public class Order
{
    public string CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
}

2. 암시적보다 명시적

null 허용 여부, 접근 한정자, 의도를 명확히 하세요.

// 좋음: 명시적 접근 한정자와 null 허용 여부
public sealed class UserService
{
    private readonly IUserRepository _repository;
    private readonly ILogger<UserService> _logger;

    public UserService(IUserRepository repository, ILogger<UserService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    public async Task<User?> FindByIdAsync(Guid id, CancellationToken cancellationToken)
    {
        return await _repository.FindByIdAsync(id, cancellationToken);
    }
}

3. 추상화에 의존

서비스 경계에는 인터페이스를 사용하고 DI 컨테이너를 통해 등록하세요.

// 좋음: 인터페이스 기반 의존성
public interface IOrderRepository
{
    Task<Order?> FindByIdAsync(Guid id, CancellationToken cancellationToken);
    Task<IReadOnlyList<Order>> FindByCustomerAsync(string customerId, CancellationToken cancellationToken);
    Task AddAsync(Order order, CancellationToken cancellationToken);
}

// 등록
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();

Async/Await 패턴

올바른 비동기 사용법

// 좋음: CancellationToken과 함께 완전 비동기 방식
public async Task<OrderSummary> GetOrderSummaryAsync(
    Guid orderId,
    CancellationToken cancellationToken)
{
    var order = await _repository.FindByIdAsync(orderId, cancellationToken)
        ?? throw new NotFoundException($"Order {orderId} not found");

    var customer = await _customerService.GetAsync(order.CustomerId, cancellationToken);

    return new OrderSummary(order, customer);
}

// 나쁨: async를 차단
public OrderSummary GetOrderSummary(Guid orderId)
{
    var order = _repository.FindByIdAsync(orderId, CancellationToken.None).Result; // 교착 상태 위험
    return new OrderSummary(order);
}

병렬 비동기 연산

// 좋음: 동시 독립 연산
public async Task<DashboardData> LoadDashboardAsync(CancellationToken cancellationToken)
{
    var ordersTask = _orderService.GetRecentAsync(cancellationToken);
    var metricsTask = _metricsService.GetCurrentAsync(cancellationToken);
    var alertsTask = _alertService.GetActiveAsync(cancellationToken);

    await Task.WhenAll(ordersTask, metricsTask, alertsTask);

    return new DashboardData(
        Orders: await ordersTask,
        Metrics: await metricsTask,
        Alerts: await alertsTask);
}

Options 패턴

구성 섹션을 강력한 형식의 객체에 바인딩합니다.

public sealed class SmtpOptions
{
    public const string SectionName = "Smtp";

    public required string Host { get; init; }
    public required int Port { get; init; }
    public required string Username { get; init; }
    public bool UseSsl { get; init; } = true;
}

// 등록
builder.Services.Configure<SmtpOptions>(
    builder.Configuration.GetSection(SmtpOptions.SectionName));

// 주입을 통한 사용
public class EmailService(IOptions<SmtpOptions> options)
{
    private readonly SmtpOptions _smtp = options.Value;
}

Result 패턴

예상되는 실패에 대해 예외를 던지는 대신 명시적인 성공/실패를 반환합니다.

public sealed record Result<T>
{
    public bool IsSuccess { get; }
    public T? Value { get; }
    public string? Error { get; }

    private Result(T value) { IsSuccess = true; Value = value; }
    private Result(string error) { IsSuccess = false; Error = error; }

    public static Result<T> Success(T value) => new(value);
    public static Result<T> Failure(string error) => new(error);
}

// 사용
public async Task<Result<Order>> PlaceOrderAsync(CreateOrderRequest request)
{
    if (request.Items.Count == 0)
        return Result<Order>.Failure("Order must contain at least one item");

    var order = Order.Create(request);
    await _repository.AddAsync(order, CancellationToken.None);
    return Result<Order>.Success(order);
}

EF Core를 사용한 Repository 패턴

public sealed class SqlOrderRepository : IOrderRepository
{
    private readonly AppDbContext _db;

    public SqlOrderRepository(AppDbContext db) => _db = db;

    public async Task<Order?> FindByIdAsync(Guid id, CancellationToken cancellationToken)
    {
        return await _db.Orders
            .Include(o => o.Items)
            .AsNoTracking()
            .FirstOrDefaultAsync(o => o.Id == id, cancellationToken);
    }

    public async Task<IReadOnlyList<Order>> FindByCustomerAsync(
        string customerId,
        CancellationToken cancellationToken)
    {
        return await _db.Orders
            .Where(o => o.CustomerId == customerId)
            .OrderByDescending(o => o.CreatedAt)
            .AsNoTracking()
            .ToListAsync(cancellationToken);
    }

    public async Task AddAsync(Order order, CancellationToken cancellationToken)
    {
        _db.Orders.Add(order);
        await _db.SaveChangesAsync(cancellationToken);
    }
}

미들웨어와 파이프라인

// 사용자 정의 미들웨어
public sealed class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestTimingMiddleware> _logger;

    public RequestTimingMiddleware(RequestDelegate next, ILogger<RequestTimingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        try
        {
            await _next(context);
        }
        finally
        {
            stopwatch.Stop();
            _logger.LogInformation(
                "Request {Method} {Path} completed in {ElapsedMs}ms with status {StatusCode}",
                context.Request.Method,
                context.Request.Path,
                stopwatch.ElapsedMilliseconds,
                context.Response.StatusCode);
        }
    }
}

Minimal API 패턴

// 라우트 그룹으로 구성
var orders = app.MapGroup("/api/orders")
    .RequireAuthorization()
    .WithTags("Orders");

orders.MapGet("/{id:guid}", async (
    Guid id,
    IOrderRepository repository,
    CancellationToken cancellationToken) =>
{
    var order = await repository.FindByIdAsync(id, cancellationToken);
    return order is not null
        ? TypedResults.Ok(order)
        : TypedResults.NotFound();
});

orders.MapPost("/", async (
    CreateOrderRequest request,
    IOrderService service,
    CancellationToken cancellationToken) =>
{
    var result = await service.PlaceOrderAsync(request, cancellationToken);
    return result.IsSuccess
        ? TypedResults.Created($"/api/orders/{result.Value!.Id}", result.Value)
        : TypedResults.BadRequest(result.Error);
});

Guard 절

// 좋음: 명확한 유효성 검사와 함께 조기 반환
public async Task<ProcessResult> ProcessPaymentAsync(
    PaymentRequest request,
    CancellationToken cancellationToken)
{
    ArgumentNullException.ThrowIfNull(request);

    if (request.Amount <= 0)
        throw new ArgumentOutOfRangeException(nameof(request.Amount), "금액은 양수여야 합니다");

    if (string.IsNullOrWhiteSpace(request.Currency))
        throw new ArgumentException("통화는 필수입니다", nameof(request.Currency));

    // 중첩 없이 정상 경로 계속
    var gateway = _gatewayFactory.Create(request.Currency);
    return await gateway.ChargeAsync(request, cancellationToken);
}

피해야 할 안티 패턴

안티 패턴	해결 방법
async void 메서드	Task 반환 (이벤트 핸들러 제외)
.Result 또는 .Wait()	await 사용
catch (Exception) { }	처리하거나 컨텍스트와 함께 다시 throw
생성자에서 new Service()	생성자 주입 사용
public 필드	적절한 접근자를 가진 속성 사용
비즈니스 로직에서 dynamic	제네릭 또는 명시적 형식 사용
변경 가능한 static 상태	DI 범위 지정 또는 ConcurrentDictionary 사용
루프 내 string.Format	StringBuilder 또는 보간 문자열 처리기 사용