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();
    }
}