C# 클린 아키텍처 완벽 가이드: 면접 대비 및 구현 패턴 2026

// ❌ Bad: 여러 책임을 가진 클래스
public class UserService
{
    public void CreateUser(User user) { /* ... */ }
    public void SendEmail(string email, string message) { /* ... */ }
    public void LogActivity(string activity) { /* ... */ }
}

// ✅ Good: 단일 책임으로 분리
public class UserService
{
    private readonly IEmailService _emailService;
    private readonly ILogger<UserService> _logger;

    public UserService(IEmailService emailService, ILogger<UserService> logger)
    {
        _emailService = emailService;
        _logger = logger;
    }

    public async Task CreateUserAsync(User user)
    {
        // 사용자 생성에만 집중
        await _userRepository.AddAsync(user);
        _logger.LogInformation("User created: {UserId}", user.Id);
    }
}

// ❌ Bad: 새로운 결제 방식 추가 시 클래스 수정 필요
public class PaymentProcessor
{
    public void ProcessPayment(string paymentType, decimal amount)
    {
        if (paymentType == "CreditCard")
        {
            // 신용카드 처리
        }
        else if (paymentType == "PayPal")
        {
            // PayPal 처리
        }
    }
}

// ✅ Good: 확장에는 열려있고 수정에는 닫혀있음
public interface IPaymentStrategy
{
    Task ProcessAsync(decimal amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public async Task ProcessAsync(decimal amount)
    {
        // 신용카드 고유 처리
    }
}

public class PayPalPayment : IPaymentStrategy
{
    public async Task ProcessAsync(decimal amount)
    {
        // PayPal 고유 처리
    }
}

public class PaymentProcessor
{
    private readonly IPaymentStrategy _paymentStrategy;

    public PaymentProcessor(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public async Task ProcessPaymentAsync(decimal amount)
    {
        await _paymentStrategy.ProcessAsync(amount);
    }
}

// ❌ Bad: LSP 위반 - 파생 클래스가 기반 클래스의 계약을 위반
public class Bird
{
    public virtual void Fly() { /* ... */ }
}

public class Penguin : Bird
{
    public override void Fly()
    {
        throw new NotSupportedException("Penguins cannot fly");
    }
}

// ✅ Good: 인터페이스로 적절히 분리
public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

public class Sparrow : IFlyable
{
    public void Fly() { /* ... */ }
}

public class Penguin : ISwimmable
{
    public void Swim() { /* ... */ }
}

// ❌ Bad: 거대한 인터페이스
public interface IWorker
{
    void Work();
    void Eat();
    void Sleep();
}

// ✅ Good: 역할별로 분리된 인터페이스
public interface IWorkable
{
    void Work();
}

public interface IFeedable
{
    void Eat();
}

public interface ISleepable
{
    void Sleep();
}

public class HumanWorker : IWorkable, IFeedable, ISleepable
{
    public void Work() { /* ... */ }
    public void Eat() { /* ... */ }
    public void Sleep() { /* ... */ }
}

public class RobotWorker : IWorkable
{
    public void Work() { /* ... */ }
}

// ❌ Bad: 상위 모듈이 하위 모듈에 의존
public class OrderService
{
    private readonly SqlOrderRepository _repository = new SqlOrderRepository();

    public void CreateOrder(Order order)
    {
        _repository.Save(order);
    }
}

// ✅ Good: 둘 다 추상화에 의존
public interface IOrderRepository
{
    Task SaveAsync(Order order);
    Task<Order?> GetByIdAsync(Guid id);
}

public class OrderService
{
    private readonly IOrderRepository _repository;

    public OrderService(IOrderRepository repository)
    {
        _repository = repository;
    }

    public async Task CreateOrderAsync(Order order)
    {
        await _repository.SaveAsync(order);
    }
}

Solution/
├── src/
│   ├── Domain/
│   │   ├── Entities/
│   │   ├── ValueObjects/
│   │   ├── Interfaces/
│   │   └── Exceptions/
│   ├── Application/
│   │   ├── Common/
│   │   │   ├── Interfaces/
│   │   │   └── Behaviors/
│   │   ├── Features/
│   │   │   └── Orders/
│   │   │       ├── Commands/
│   │   │       └── Queries/
│   │   └── DTOs/
│   ├── Infrastructure/
│   │   ├── Persistence/
│   │   ├── Services/
│   │   └── DependencyInjection.cs
│   └── WebApi/
│       ├── Controllers/
│       ├── Filters/
│       └── Program.cs
└── tests/
    ├── Domain.Tests/
    ├── Application.Tests/
    └── Integration.Tests/

// Command 정의
public record CreateOrderCommand(string CustomerId, List<OrderItem> Items) 
    : IRequest<Result<Guid>>;

// Command 핸들러
public class CreateOrderCommandHandler 
    : IRequestHandler<CreateOrderCommand, Result<Guid>>
{
    private readonly IOrderRepository _orderRepository;
    private readonly IUnitOfWork _unitOfWork;

    public CreateOrderCommandHandler(
        IOrderRepository orderRepository,
        IUnitOfWork unitOfWork)
    {
        _orderRepository = orderRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<Result<Guid>> Handle(
        CreateOrderCommand request, 
        CancellationToken cancellationToken)
    {
        var order = Order.Create(request.CustomerId, request.Items);
        
        await _orderRepository.AddAsync(order, cancellationToken);
        await _unitOfWork.SaveChangesAsync(cancellationToken);
        
        return Result.Success(order.Id);
    }
}

// Query 정의
public record GetOrderByIdQuery(Guid OrderId) : IRequest<OrderDto?>;

// Query 핸들러
public class GetOrderByIdQueryHandler 
    : IRequestHandler<GetOrderByIdQuery, OrderDto?>
{
    private readonly IOrderRepository _orderRepository;
    private readonly IMapper _mapper;

    public GetOrderByIdQueryHandler(
        IOrderRepository orderRepository,
        IMapper mapper)
    {
        _orderRepository = orderRepository;
        _mapper = mapper;
    }

    public async Task<OrderDto?> Handle(
        GetOrderByIdQuery request, 
        CancellationToken cancellationToken)
    {
        var order = await _orderRepository
            .GetByIdAsync(request.OrderId, cancellationToken);
        
        return order is null ? null : _mapper.Map<OrderDto>(order);
    }
}

public class CreateOrderCommandValidator 
    : AbstractValidator<CreateOrderCommand>
{
    public CreateOrderCommandValidator()
    {
        RuleFor(x => x.CustomerId)
            .NotEmpty()
            .WithMessage("고객 ID는 필수입니다");

        RuleFor(x => x.Items)
            .NotEmpty()
            .WithMessage("주문에는 최소 1개의 상품이 필요합니다");

        RuleForEach(x => x.Items)
            .ChildRules(item =>
            {
                item.RuleFor(x => x.Quantity)
                    .GreaterThan(0)
                    .WithMessage("수량은 1 이상이어야 합니다");
            });
    }
}

// ValidationBehavior(MediatR 파이프라인)
public class ValidationBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;

    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }

    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        if (!_validators.Any())
            return await next();

        var context = new ValidationContext<TRequest>(request);
        var failures = _validators
            .Select(v => v.Validate(context))
            .SelectMany(result => result.Errors)
            .Where(f => f != null)
            .ToList();

        if (failures.Any())
            throw new ValidationException(failures);

        return await next();
    }
}