❌ 나쁜 예제 - Singleton 없이 구현

public class ConfigurationManager
{
    private Dictionary<string, string> settings;
    
    public ConfigurationManager()
    {
        settings = new Dictionary<string, string>();
        LoadSettings(); // 매번 파일에서 설정을 읽어옴
    }
    
    private void LoadSettings()
    {
        // 파일에서 설정 로드 (비용이 큰 작업)
    }
}

// 사용하는 곳마다 새로운 인스턴스 생성
var config1 = new ConfigurationManager(); // 파일 읽기
var config2 = new ConfigurationManager(); // 또 파일 읽기
var config3 = new ConfigurationManager(); // 또또 파일 읽기
// 메모리 낭비, 성능 저하!

✅ 좋은 예제 - Singleton 패턴 적용

public sealed class ConfigurationManager
{
    private static readonly Lazy<ConfigurationManager> instance = 
        new Lazy<ConfigurationManager>(() => new ConfigurationManager());
    
    private Dictionary<string, string> settings;
    
    // private 생성자로 외부에서 인스턴스 생성 방지
    private ConfigurationManager()
    {
        settings = new Dictionary<string, string>();
        LoadSettings(); // 딱 한 번만 실행됨
    }
    
    public static ConfigurationManager Instance => instance.Value;
    
    private void LoadSettings()
    {
        // 파일에서 설정 로드
        settings["DatabaseConnection"] = "Server=localhost;Database=MyDB";
        settings["ApiKey"] = "abc123xyz";
    }
    
    public string GetSetting(string key)
    {
        return settings.ContainsKey(key) ? settings[key] : null;
    }
}

// 사용 예제
var config1 = ConfigurationManager.Instance;
var config2 = ConfigurationManager.Instance;
var config3 = ConfigurationManager.Instance;
// 모두 같은 인스턴스를 참조! (config1 == config2 == config3)

string dbConnection = ConfigurationManager.Instance.GetSetting("DatabaseConnection");

실전 예제 - 다양한 결제 방식 처리

// 결제 인터페이스
public interface IPaymentProcessor
{
    bool ProcessPayment(decimal amount);
    string GetPaymentMethod();
}

// 신용카드 결제
public class CreditCardPayment : IPaymentProcessor
{
    private string cardNumber;
    
    public CreditCardPayment(string cardNumber)
    {
        this.cardNumber = cardNumber;
    }
    
    public bool ProcessPayment(decimal amount)
    {
        Console.WriteLine($"신용카드로 {amount}원 결제 처리 중...");
        // 실제 결제 로직
        return true;
    }
    
    public string GetPaymentMethod() => "신용카드";
}

// 계좌이체 결제
public class BankTransferPayment : IPaymentProcessor
{
    private string accountNumber;
    
    public BankTransferPayment(string accountNumber)
    {
        this.accountNumber = accountNumber;
    }
    
    public bool ProcessPayment(decimal amount)
    {
        Console.WriteLine($"계좌이체로 {amount}원 결제 처리 중...");
        // 실제 결제 로직
        return true;
    }
    
    public string GetPaymentMethod() => "계좌이체";
}

// 카카오페이 결제
public class KakaoPayPayment : IPaymentProcessor
{
    private string userId;
    
    public KakaoPayPayment(string userId)
    {
        this.userId = userId;
    }
    
    public bool ProcessPayment(decimal amount)
    {
        Console.WriteLine($"카카오페이로 {amount}원 결제 처리 중...");
        // 실제 결제 로직
        return true;
    }
    
    public string GetPaymentMethod() => "카카오페이";
}

// Factory 클래스
public class PaymentProcessorFactory
{
    public static IPaymentProcessor CreatePaymentProcessor(
        string paymentType, string credential)
    {
        switch (paymentType.ToLower())
        {
            case "creditcard":
                return new CreditCardPayment(credential);
            case "banktransfer":
                return new BankTransferPayment(credential);
            case "kakaopay":
                return new KakaoPayPayment(credential);
            default:
                throw new ArgumentException($"지원하지 않는 결제 방식: {paymentType}");
        }
    }
}

// 사용 예제
public class OrderService
{
    public void ProcessOrder(string paymentType, string credential, decimal amount)
    {
        // Factory를 통해 적절한 결제 프로세서 생성
        IPaymentProcessor processor = 
            PaymentProcessorFactory.CreatePaymentProcessor(paymentType, credential);
        
        Console.WriteLine($"{processor.GetPaymentMethod()} 선택됨");
        
        if (processor.ProcessPayment(amount))
        {
            Console.WriteLine("결제 성공! ✅");
        }
        else
        {
            Console.WriteLine("결제 실패! ❌");
        }
    }
}

// 실행
var orderService = new OrderService();
orderService.ProcessOrder("creditcard", "1234-5678-9012-3456", 50000);
orderService.ProcessOrder("kakaopay", "user123", 30000);

실전 예제 - 다양한 할인 정책

// 할인 전략 인터페이스
public interface IDiscountStrategy
{
    decimal ApplyDiscount(decimal originalPrice);
    string GetDiscountDescription();
}

// 정액 할인
public class FixedAmountDiscount : IDiscountStrategy
{
    private readonly decimal discountAmount;
    
    public FixedAmountDiscount(decimal amount)
    {
        discountAmount = amount;
    }
    
    public decimal ApplyDiscount(decimal originalPrice)
    {
        return Math.Max(0, originalPrice - discountAmount);
    }
    
    public string GetDiscountDescription()
    {
        return $"{discountAmount}원 할인";
    }
}

// 정률 할인
public class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal percentage;
    
    public PercentageDiscount(decimal percent)
    {
        percentage = percent;
    }
    
    public decimal ApplyDiscount(decimal originalPrice)
    {
        return originalPrice * (1 - percentage / 100);
    }
    
    public string GetDiscountDescription()
    {
        return $"{percentage}% 할인";
    }
}

// VIP 회원 할인 (복합 할인)
public class VipMemberDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal originalPrice)
    {
        // 기본 20% 할인 + 10만원 이상 구매시 추가 5% 할인
        decimal discountedPrice = originalPrice * 0.8m;
        
        if (originalPrice >= 100000)
        {
            discountedPrice *= 0.95m;
        }
        
        return discountedPrice;
    }
    
    public string GetDiscountDescription()
    {
        return "VIP 회원 특별 할인 (20% + 추가 할인)";
    }
}

// 할인 없음
public class NoDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal originalPrice)
    {
        return originalPrice;
    }
    
    public string GetDiscountDescription()
    {
        return "할인 없음";
    }
}

// 쇼핑 카트 클래스
public class ShoppingCart
{
    private List<decimal> items = new List<decimal>();
    private IDiscountStrategy discountStrategy;
    
    public ShoppingCart()
    {
        // 기본값은 할인 없음
        discountStrategy = new NoDiscount();
    }
    
    public void AddItem(decimal price)
    {
        items.Add(price);
        Console.WriteLine($"상품 추가: {price}원");
    }
    
    // 할인 전략을 동적으로 변경 가능!
    public void SetDiscountStrategy(IDiscountStrategy strategy)
    {
        discountStrategy = strategy;
        Console.WriteLine($"할인 정책 변경: {strategy.GetDiscountDescription()}");
    }
    
    public decimal GetTotalPrice()
    {
        decimal originalTotal = items.Sum();
        decimal discountedTotal = discountStrategy.ApplyDiscount(originalTotal);
        
        Console.WriteLine($"\n원래 가격: {originalTotal}원");
        Console.WriteLine($"할인 적용: {discountStrategy.GetDiscountDescription()}");
        Console.WriteLine($"최종 가격: {discountedTotal}원");
        Console.WriteLine($"절약 금액: {originalTotal - discountedTotal}원 💰\n");
        
        return discountedTotal;
    }
}

// 사용 예제
var cart = new ShoppingCart();
cart.AddItem(50000);
cart.AddItem(30000);
cart.AddItem(40000);

// 할인 없이 계산
cart.GetTotalPrice();

// 정액 할인 적용
cart.SetDiscountStrategy(new FixedAmountDiscount(10000));
cart.GetTotalPrice();

// 정률 할인 적용
cart.SetDiscountStrategy(new PercentageDiscount(15));
cart.GetTotalPrice();

// VIP 회원 할인 적용
cart.SetDiscountStrategy(new VipMemberDiscount());
cart.GetTotalPrice();

실전 예제 - 주식 가격 모니터링 시스템

// 주식 가격 변동 이벤트 인자
public class StockPriceChangedEventArgs : EventArgs
{
    public string StockSymbol { get; set; }
    public decimal OldPrice { get; set; }
    public decimal NewPrice { get; set; }
    public decimal ChangePercentage { get; set; }
    public DateTime Timestamp { get; set; }
}

// 주식 (Subject/Observable)
public class Stock
{
    private string symbol;
    private decimal price;
    
    // 이벤트 선언
    public event EventHandler<StockPriceChangedEventArgs> PriceChanged;
    
    public Stock(string symbol, decimal initialPrice)
    {
        this.symbol = symbol;
        this.price = initialPrice;
    }
    
    public string Symbol => symbol;
    public decimal Price => price;
    
    public void UpdatePrice(decimal newPrice)
    {
        if (price != newPrice)
        {
            decimal oldPrice = price;
            price = newPrice;
            
            // 가격 변동률 계산
            decimal changePercentage = ((newPrice - oldPrice) / oldPrice) * 100;
            
            // 이벤트 발생
            OnPriceChanged(new StockPriceChangedEventArgs
            {
                StockSymbol = symbol,
                OldPrice = oldPrice,
                NewPrice = newPrice,
                ChangePercentage = changePercentage,
                Timestamp = DateTime.Now
            });
        }
    }
    
    protected virtual void OnPriceChanged(StockPriceChangedEventArgs e)
    {
        PriceChanged?.Invoke(this, e);
    }
}

// 관찰자 1: 이메일 알림 서비스
public class EmailNotificationService
{
    private string emailAddress;
    
    public EmailNotificationService(string email)
    {
        emailAddress = email;
    }
    
    public void Subscribe(Stock stock)
    {
        stock.PriceChanged += OnStockPriceChanged;
        Console.WriteLine($"📧 {emailAddress}로 {stock.Symbol} 알림 구독 시작");
    }
    
    public void Unsubscribe(Stock stock)
    {
        stock.PriceChanged -= OnStockPriceChanged;
        Console.WriteLine($"📧 {emailAddress}의 {stock.Symbol} 알림 구독 해제");
    }
    
    private void OnStockPriceChanged(object sender, StockPriceChangedEventArgs e)
    {
        string direction = e.ChangePercentage > 0 ? "상승 📈" : "하락 📉";
        Console.WriteLine($"\n[이메일 발송] {emailAddress}");
        Console.WriteLine($"{e.StockSymbol} 가격 {direction}");
        Console.WriteLine($"{e.OldPrice}원 → {e.NewPrice}원 ({e.ChangePercentage:F2}%)");
    }
}

// 관찰자 2: SMS 알림 서비스
public class SmsNotificationService
{
    private string phoneNumber;
    private decimal alertThreshold;
    
    public SmsNotificationService(string phone, decimal threshold)
    {
        phoneNumber = phone;
        alertThreshold = threshold;
    }
    
    public void Subscribe(Stock stock)
    {
        stock.PriceChanged += OnStockPriceChanged;
        Console.WriteLine($"📱 {phoneNumber}로 {stock.Symbol} SMS 알림 구독 (임계값: {alertThreshold}%)");
    }
    
    private void OnStockPriceChanged(object sender, StockPriceChangedEventArgs e)
    {
        // 변동률이 임계값을 초과할 때만 SMS 발송
        if (Math.Abs(e.ChangePercentage) >= alertThreshold)
        {
            Console.WriteLine($"\n[긴급 SMS] {phoneNumber}");
            Console.WriteLine($"⚠️ {e.StockSymbol} 급격한 변동 감지!");
            Console.WriteLine($"변동률: {e.ChangePercentage:F2}%");
        }
    }
}

// 관찰자 3: 로깅 서비스
public class StockPriceLogger
{
    private string logFilePath;
    
    public StockPriceLogger(string filePath)
    {
        logFilePath = filePath;
    }
    
    public void Subscribe(Stock stock)
    {
        stock.PriceChanged += OnStockPriceChanged;
        Console.WriteLine($"📝 {stock.Symbol} 가격 변동 로깅 시작");
    }
    
    private void OnStockPriceChanged(object sender, StockPriceChangedEventArgs e)
    {
        string logEntry = $"[{e.Timestamp:yyyy-MM-dd HH:mm:ss}] " +
                         $"{e.StockSymbol}: {e.OldPrice} → {e.NewPrice} " +
                         $"({e.ChangePercentage:F2}%)";
        
        Console.WriteLine($"\n[로그 기록] {logEntry}");
        // 실제로는 파일에 기록
    }
}

// 사용 예제
var samsungStock = new Stock("삼성전자", 70000);

// 여러 관찰자 등록
var emailService = new EmailNotificationService("investor@example.com");
var smsService = new SmsNotificationService("010-1234-5678", 3.0m);
var logger = new StockPriceLogger("stock_prices.log");

emailService.Subscribe(samsungStock);
smsService.Subscribe(samsungStock);
logger.Subscribe(samsungStock);

Console.WriteLine("\n=== 주식 가격 변동 시뮬레이션 ===\n");

// 가격 변동 - 모든 관찰자에게 자동으로 알림!
samsungStock.UpdatePrice(71500);  // 2.14% 상승
Thread.Sleep(1000);

samsungStock.UpdatePrice(73000);  // 2.10% 상승
Thread.Sleep(1000);

samsungStock.UpdatePrice(70500);  // 3.42% 하락 (SMS 발송!)
Thread.Sleep(1000);

// 특정 관찰자 구독 해제
emailService.Unsubscribe(samsungStock);

samsungStock.UpdatePrice(72000);  // 이메일은 안 감!

❌ 나쁜 예제 - 강한 결합

// 데이터베이스 접근 클래스
public class SqlServerDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine($"SQL Server에 데이터 저장: {data}");
        // 실제 SQL Server 저장 로직
    }
}

// 사용자 서비스 - 직접 의존성 생성
public class UserService
{
    private SqlServerDatabase database;
    
    public UserService()
    {
        // 문제: SqlServerDatabase에 강하게 결합됨!
        database = new SqlServerDatabase();
    }
    
    public void RegisterUser(string username)
    {
        Console.WriteLine($"사용자 등록: {username}");
        database.SaveData(username);
    }
}

// 문제점들:
// 1. UserService는 SqlServerDatabase에 강하게 결합됨
// 2. 다른 데이터베이스(MySQL, MongoDB)로 변경하려면 UserService 코드 수정 필요
// 3. 테스트할 때 실제 데이터베이스 없이 테스트 불가능
// 4. UserService를 재사용하기 어려움

✅ 좋은 예제 - 의존성 주입 적용

// 데이터베이스 인터페이스 (추상화)
public interface IDatabase
{
    void SaveData(string data);
}

// SQL Server 구현
public class SqlServerDatabase : IDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine($"SQL Server에 데이터 저장: {data}");
    }
}

// MySQL 구현
public class MySqlDatabase : IDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine($"MySQL에 데이터 저장: {data}");
    }
}

// MongoDB 구현
public class MongoDatabase : IDatabase
{
    public void SaveData(string data)
    {
        Console.WriteLine($"MongoDB에 데이터 저장: {data}");
    }
}

// 테스트용 가짜 데이터베이스
public class FakeDatabase : IDatabase
{
    public List<string> SavedData { get; } = new List<string>();
    
    public void SaveData(string data)
    {
        SavedData.Add(data);
        Console.WriteLine($"테스트 DB에 데이터 저장: {data}");
    }
}

// 사용자 서비스 - 의존성 주입 받음
public class UserService
{
    private readonly IDatabase database;
    
    // 생성자를 통한 의존성 주입 (Constructor Injection)
    public UserService(IDatabase database)
    {
        this.database = database;
    }
    
    public void RegisterUser(string username)
    {
        Console.WriteLine($"사용자 등록: {username}");
        database.SaveData(username);
    }
}

// 사용 예제 - 다양한 데이터베이스로 쉽게 교체 가능!
Console.WriteLine("=== SQL Server 사용 ===");
var sqlService = new UserService(new SqlServerDatabase());
sqlService.RegisterUser("홍길동");

Console.WriteLine("\n=== MySQL 사용 ===");
var mysqlService = new UserService(new MySqlDatabase());
mysqlService.RegisterUser("김철수");

Console.WriteLine("\n=== MongoDB 사용 ===");
var mongoService = new UserService(new MongoDatabase());
mongoService.RegisterUser("이영희");

Console.WriteLine("\n=== 테스트 환경 ===");
var fakeDb = new FakeDatabase();
var testService = new UserService(fakeDb);
testService.RegisterUser("테스트유저");
Console.WriteLine($"저장된 데이터 개수: {fakeDb.SavedData.Count}개");

가장 권장되는 방법! 🌟

public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class SmtpEmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        Console.WriteLine($"SMTP로 이메일 발송: {to}");
    }
}

public class NotificationService
{
    private readonly IEmailService emailService;
    private readonly ILogger logger;
    
    // 생성자를 통해 의존성 주입
    public NotificationService(IEmailService emailService, ILogger logger)
    {
        // null 체크로 필수 의존성 보장
        this.emailService = emailService ?? throw new ArgumentNullException(nameof(emailService));
        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
    
    public void SendWelcomeEmail(string userEmail)
    {
        logger.Log("환영 이메일 발송 시작");
        emailService.SendEmail(userEmail, "환영합니다!", "회원가입을 축하합니다.");
        logger.Log("환영 이메일 발송 완료");
    }
}

// 사용
var emailService = new SmtpEmailService();
var logger = new ConsoleLogger();
var notificationService = new NotificationService(emailService, logger);

선택적 의존성에 사용

public class ReportGenerator
{
    // 필수 의존성은 생성자로
    private readonly IDataSource dataSource;
    
    public ReportGenerator(IDataSource dataSource)
    {
        this.dataSource = dataSource;
    }
    
    // 선택적 의존성은 속성으로
    public ILogger Logger { get; set; }
    public IEmailService EmailService { get; set; }
    
    public void GenerateReport()
    {
        Logger?.Log("리포트 생성 시작");
        
        var data = dataSource.GetData();
        var report = CreateReport(data);
        
        Logger?.Log("리포트 생성 완료");
        
        // 이메일 서비스가 설정되어 있으면 발송
        if (EmailService != null)
        {
            EmailService.SendEmail("admin@example.com", "리포트", report);
        }
    }
    
    private string CreateReport(object data)
    {
        return "리포트 내용...";
    }
}

// 사용
var generator = new ReportGenerator(new SqlDataSource());
generator.Logger = new FileLogger(); // 선택적으로 설정
generator.EmailService = new SmtpEmailService(); // 선택적으로 설정
generator.GenerateReport();

특정 메서드 실행 시에만 필요한 의존성

public class DocumentProcessor
{
    public void ProcessDocument(string documentPath, IDocumentValidator validator)
    {
        // 메서드 파라미터로 의존성 주입
        if (!validator.Validate(documentPath))
        {
            throw new InvalidOperationException("문서 검증 실패");
        }
        
        Console.WriteLine($"문서 처리 중: {documentPath}");
        // 문서 처리 로직
    }
    
    public void ConvertDocument(string sourcePath, string targetPath, 
                               IDocumentConverter converter)
    {
        // 다른 메서드에서는 다른 의존성 주입
        converter.Convert(sourcePath, targetPath);
    }
}

// 사용 - 메서드 호출 시마다 다른 구현체 전달 가능
var processor = new DocumentProcessor();

processor.ProcessDocument("doc1.pdf", new PdfValidator());
processor.ProcessDocument("doc2.docx", new WordValidator());

processor.ConvertDocument("source.pdf", "target.docx", new PdfToWordConverter());
processor.ConvertDocument("source.docx", "target.pdf", new WordToPdfConverter());

서비스 등록과 사용

// Startup.cs 또는 Program.cs
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 1. Transient: 요청할 때마다 새 인스턴스 생성
        services.AddTransient<IEmailService, SmtpEmailService>();
        
        // 2. Scoped: HTTP 요청당 하나의 인스턴스 (웹 애플리케이션)
        services.AddScoped<IUserRepository, SqlUserRepository>();
        
        // 3. Singleton: 애플리케이션 전체에서 하나의 인스턴스
        services.AddSingleton<IConfiguration, AppConfiguration>();
        
        // 구체 클래스도 등록 가능
        services.AddTransient<NotificationService>();
        
        // 팩토리 패턴으로 등록
        services.AddTransient<IPaymentProcessor>(provider =>
        {
            var config = provider.GetRequiredService<IConfiguration>();
            var paymentType = config.GetSetting("PaymentType");
            
            return paymentType switch
            {
                "CreditCard" => new CreditCardPayment("default"),
                "BankTransfer" => new BankTransferPayment("default"),
                _ => throw new InvalidOperationException("지원하지 않는 결제 방식")
            };
        });
    }
}

// 컨트롤러에서 사용
public class UserController : ControllerBase
{
    private readonly IUserRepository userRepository;
    private readonly IEmailService emailService;
    private readonly ILogger<UserController> logger;
    
    // 생성자에 필요한 의존성 선언만 하면 자동으로 주입됨!
    public UserController(
        IUserRepository userRepository,
        IEmailService emailService,
        ILogger<UserController> logger)
    {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.logger = logger;
    }
    
    [HttpPost]
    public async Task<IActionResult> Register(UserRegistrationDto dto)
    {
        logger.LogInformation($"사용자 등록 시도: {dto.Email}");
        
        var user = await userRepository.CreateUser(dto);
        
        emailService.SendEmail(
            dto.Email,
            "환영합니다!",
            "회원가입이 완료되었습니다."
        );
        
        return Ok(user);
    }
}

테스트하기 어려운 코드 ❌

public class OrderService
{
    public bool PlaceOrder(Order order)
    {
        // 직접 의존성 생성 - 테스트 불가능!
        var paymentGateway = new PayPalGateway();
        var emailService = new SmtpEmailService();
        var database = new SqlServerDatabase();
        
        // 실제 결제 시도 (테스트 시 문제!)
        if (!paymentGateway.ProcessPayment(order.TotalAmount))
        {
            return false;
        }
        
        // 실제 DB에 저장 (테스트 시 문제!)
        database.SaveOrder(order);
        
        // 실제 이메일 발송 (테스트 시 문제!)
        emailService.SendEmail(order.CustomerEmail, "주문 확인", "주문이 완료되었습니다.");
        
        return true;
    }
}

테스트하기 쉬운 코드 ✅

// 인터페이스 정의
public interface IPaymentGateway
{
    bool ProcessPayment(decimal amount);
}

public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public interface IOrderRepository
{
    void SaveOrder(Order order);
}

// 의존성 주입을 사용하는 서비스
public class OrderService
{
    private readonly IPaymentGateway paymentGateway;
    private readonly IEmailService emailService;
    private readonly IOrderRepository orderRepository;
    
    public OrderService(
        IPaymentGateway paymentGateway,
        IEmailService emailService,
        IOrderRepository orderRepository)
    {
        this.paymentGateway = paymentGateway;
        this.emailService = emailService;
        this.orderRepository = orderRepository;
    }
    
    public bool PlaceOrder(Order order)
    {
        if (!paymentGateway.ProcessPayment(order.TotalAmount))
        {
            return false;
        }
        
        orderRepository.SaveOrder(order);
        emailService.SendEmail(order.CustomerEmail, "주문 확인", "주문이 완료되었습니다.");
        
        return true;
    }
}

// 단위 테스트 (xUnit + Moq 사용)
public class OrderServiceTests
{
    [Fact]
    public void PlaceOrder_성공적인결제_주문저장및이메일발송()
    {
        // Arrange - 테스트 준비
        var mockPaymentGateway = new Mock<IPaymentGateway>();
        var mockEmailService = new Mock<IEmailService>();
        var mockOrderRepository = new Mock<IOrderRepository>();
        
        // Mock 동작 설정
        mockPaymentGateway
            .Setup(x => x.ProcessPayment(It.IsAny<decimal>()))
            .Returns(true); // 결제 성공 시뮬레이션
        
        var orderService = new OrderService(
            mockPaymentGateway.Object,
            mockEmailService.Object,
            mockOrderRepository.Object
        );
        
        var order = new Order
        {
            OrderId = 1,
            CustomerEmail = "test@example.com",
            TotalAmount = 50000
        };
        
        // Act - 테스트 실행
        var result = orderService.PlaceOrder(order);
        
        // Assert - 결과 검증
        Assert.True(result);
        
        // 결제가 정확한 금액으로 호출되었는지 검증
        mockPaymentGateway.Verify(
            x => x.ProcessPayment(50000),
            Times.Once
        );
        
        // 주문이 저장되었는지 검증
        mockOrderRepository.Verify(
            x => x.SaveOrder(order),
            Times.Once
        );
        
        // 이메일이 발송되었는지 검증
        mockEmailService.Verify(
            x => x.SendEmail(
                "test@example.com",
                "주문 확인",
                It.IsAny<string>()
            ),
            Times.Once
        );
    }
    
    [Fact]
    public void PlaceOrder_결제실패_주문저장안됨()
    {
        // Arrange
        var mockPaymentGateway = new Mock<IPaymentGateway>();
        var mockEmailService = new Mock<IEmailService>();
        var mockOrderRepository = new Mock<IOrderRepository>();
        
        // 결제 실패 시뮬레이션
        mockPaymentGateway
            .Setup(x => x.ProcessPayment(It.IsAny<decimal>()))
            .Returns(false);
        
        var orderService = new OrderService(
            mockPaymentGateway.Object,
            mockEmailService.Object,
            mockOrderRepository.Object
        );
        
        var order = new Order { OrderId = 1, TotalAmount = 50000 };
        
        // Act
        var result = orderService.PlaceOrder(order);
        
        // Assert
        Assert.False(result);
        
        // 결제 실패 시 주문 저장과 이메일 발송이 호출되지 않았는지 검증
        mockOrderRepository.Verify(
            x => x.SaveOrder(It.IsAny<Order>()),
            Times.Never
        );
        
        mockEmailService.Verify(
            x => x.SendEmail(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()),
            Times.Never
        );
    }
}

하나의 클래스는 하나의 책임만 가져야 해!

// ❌ 나쁜 예 - 여러 책임을 가진 클래스
public class User
{
    public string Name { get; set; }
    public string Email { get; set; }
    
    // 사용자 데이터 검증
    public bool Validate()
    {
        return !string.IsNullOrEmpty(Name) && Email.Contains("@");
    }
    
    // 데이터베이스 저장
    public void Save()
    {
        // DB 저장 로직
    }
    
    // 이메일 발송
    public void SendWelcomeEmail()
    {
        // 이메일 발송 로직
    }
    
    // 로그 기록
    public void LogActivity()
    {
        // 로깅 로직
    }
}

// ✅ 좋은 예 - 책임 분리
public class User
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class UserValidator
{
    public bool Validate(User user)
    {
        return !string.IsNullOrEmpty(user.Name) && user.Email.Contains("@");
    }
}

public class UserRepository
{
    public void Save(User user)
    {
        // DB 저장 로직
    }
}

public class UserEmailService
{
    public void SendWelcomeEmail(User user)
    {
        // 이메일 발송 로직
    }
}

public class UserActivityLogger
{
    public void LogActivity(User user, string activity)
    {
        // 로깅 로직
    }
}

확장에는 열려있고, 수정에는 닫혀있어야 해!

// ❌ 나쁜 예 - 새로운 도형 추가 시 기존 코드 수정 필요
public class AreaCalculator
{
    public double CalculateArea(object shape)
    {
        if (shape is Rectangle rectangle)
        {
            return rectangle.Width * rectangle.Height;
        }
        else if (shape is Circle circle)
        {
            return Math.PI * circle.Radius * circle.Radius;
        }
        // 새로운 도형 추가 시 여기를 수정해야 함!
        
        return 0;
    }
}

// ✅ 좋은 예 - Strategy 패턴 활용
public interface IShape
{
    double CalculateArea();
}

public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public double CalculateArea()
    {
        return Width * Height;
    }
}

public class Circle : IShape
{
    public double Radius { get; set; }
    
    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

// 새로운 도형 추가 - 기존 코드 수정 없이 확장!
public class Triangle : IShape
{
    public double Base { get; set; }
    public double Height { get; set; }
    
    public double CalculateArea()
    {
        return 0.5 * Base * Height;
    }
}

public class AreaCalculator
{
    public double CalculateTotalArea(IEnumerable<IShape> shapes)
    {
        return shapes.Sum(shape => shape.CalculateArea());
    }
}

자식 클래스는 부모 클래스를 완전히 대체할 수 있어야 해!

// ❌ 나쁜 예 - LSP 위반
public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("날아갑니다!");
    }
}

public class Penguin : Bird
{
    public override void Fly()
    {
        // 펭귄은 날 수 없음 - LSP 위반!
        throw new NotSupportedException("펭귄은 날 수 없습니다!");
    }
}

// ✅ 좋은 예 - 인터페이스 분리
public interface IBird
{
    void Eat();
    void Move();
}

public interface IFlyable
{
    void Fly();
}

public class Sparrow : IBird, IFlyable
{
    public void Eat() => Console.WriteLine("먹이를 먹습니다.");
    public void Move() => Console.WriteLine("이동합니다.");
    public void Fly() => Console.WriteLine("날아갑니다!");
}

public class Penguin : IBird
{
    public void Eat() => Console.WriteLine("물고기를 먹습니다.");
    public void Move() => Console.WriteLine("뒤뚱뒤뚱 걷습니다.");
    // Fly 메서드 없음 - 펭귄은 날 수 없으니까!
}

클라이언트는 사용하지 않는 인터페이스에 의존하면 안 돼!

// ❌ 나쁜 예 - 거대한 인터페이스
public interface IWorker
{
    void Work();
    void Eat();
    void Sleep();
    void GetPaid();
}

public class Robot : IWorker
{
    public void Work() => Console.WriteLine("작업 중...");
    
    // 로봇은 먹지도 자지도 않는데 구현해야 함!
    public void Eat() => throw new NotImplementedException();
    public void Sleep() => throw new NotImplementedException();
    
    public void GetPaid() => Console.WriteLine("충전 중...");
}

// ✅ 좋은 예 - 인터페이스 분리
public interface IWorkable
{
    void Work();
}

public interface IFeedable
{
    void Eat();
}

public interface ISleepable
{
    void Sleep();
}

public interface IPayable
{
    void GetPaid();
}

public class Human : IWorkable, IFeedable, ISleepable, IPayable
{
    public void Work() => Console.WriteLine("일합니다.");
    public void Eat() => Console.WriteLine("식사합니다.");
    public void Sleep() => Console.WriteLine("잠을 잡니다.");
    public void GetPaid() => Console.WriteLine("급여를 받습니다.");
}

public class Robot : IWorkable, IPayable
{
    public void Work() => Console.WriteLine("작업 중...");
    public void GetPaid() => Console.WriteLine("충전 중...");
    // 필요한 인터페이스만 구현!
}

구체적인 것이 아닌 추상적인 것에 의존해야 해!

// ❌ 나쁜 예 - 구체 클래스에 의존
public class EmailNotification
{
    public void Send(string message)
    {
        Console.WriteLine($"이메일 발송: {message}");
    }
}

public class NotificationService
{
    private EmailNotification emailNotification;
    
    public NotificationService()
    {
        // 구체 클래스에 직접 의존!
        emailNotification = new EmailNotification();
    }
    
    public void Notify(string message)
    {
        emailNotification.Send(message);
    }
}

// ✅ 좋은 예 - 추상화에 의존 (의존성 주입)
public interface INotification
{
    void Send(string message);
}

public class EmailNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine($"📧 이메일 발송: {message}");
    }
}

public class SmsNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine($"📱 SMS 발송: {message}");
    }
}

public class PushNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine($"🔔 푸시 알림: {message}");
    }
}

public class NotificationService
{
    private readonly INotification notification;
    
    // 추상화(인터페이스)에 의존!
    public NotificationService(INotification notification)
    {
        this.notification = notification;
    }
    
    public void Notify(string message)
    {
        notification.Send(message);
    }
}

// 사용 - 쉽게 교체 가능!
var emailService = new NotificationService(new EmailNotification());
var smsService = new NotificationService(new SmsNotification());
var pushService = new NotificationService(new PushNotification());

프로젝트 구조 및 레이어 분리

// ========== Domain Layer (도메인 계층) ==========
// 비즈니스 로직과 엔티티

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int StockQuantity { get; set; }
    
    public bool IsAvailable() => StockQuantity > 0;
    
    public void DecreaseStock(int quantity)
    {
        if (quantity > StockQuantity)
            throw new InvalidOperationException("재고가 부족합니다.");
        
        StockQuantity -= quantity;
    }
}

public class Order
{
    public int Id { get; set; }
    public string CustomerId { get; set; }
    public List<OrderItem> Items { get; set; } = new List<OrderItem>();
    public OrderStatus Status { get; set; }
    public DateTime CreatedAt { get; set; }
    
    public decimal GetTotalAmount()
    {
        return Items.Sum(item => item.Quantity * item.UnitPrice);
    }
}

public class OrderItem
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

public enum OrderStatus
{
    Pending,
    Paid,
    Shipped,
    Delivered,
    Cancelled
}

// ========== Repository Interfaces (저장소 인터페이스) ==========

public interface IProductRepository
{
    Task<Product> GetByIdAsync(int id);
    Task<IEnumerable<Product>> GetAllAsync();
    Task<Product> AddAsync(Product product);
    Task UpdateAsync(Product product);
    Task DeleteAsync(int id);
}

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(int id);
    Task<IEnumerable<Order>> GetByCustomerIdAsync(string customerId);
    Task<Order> AddAsync(Order order);
    Task UpdateAsync(Order order);
}

// ========== Service Interfaces (서비스 인터페이스) ==========

public interface IPaymentService
{
    Task<PaymentResult> ProcessPaymentAsync(Order order, PaymentMethod method);
}

public interface INotificationService
{
    Task SendOrderConfirmationAsync(Order order);
    Task SendShippingNotificationAsync(Order order);
}

public interface IInventoryService
{
    Task<bool> CheckAvailabilityAsync(int productId, int quantity);
    Task ReserveStockAsync(int productId, int quantity);
    Task ReleaseStockAsync(int productId, int quantity);
}

// ========== Application Layer (애플리케이션 계층) ==========
// 비즈니스 로직 조율

public class OrderService
{
    private readonly IOrderRepository orderRepository;
    private readonly IProductRepository productRepository;
    private readonly IPaymentService paymentService;
    private readonly INotificationService notificationService;
    private readonly IInventoryService inventoryService;
    private readonly ILogger<OrderService> logger;
    
    public OrderService(
        IOrderRepository orderRepository,
        IProductRepository productRepository,
        IPaymentService paymentService,
        INotificationService notificationService,
        IInventoryService inventoryService,
        ILogger<OrderService> logger)
    {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
        this.inventoryService = inventoryService;
        this.logger = logger;
    }
    
    public async Task<OrderResult> PlaceOrderAsync(CreateOrderRequest request)
    {
        logger.LogInformation($"주문 생성 시작: 고객 {request.CustomerId}");
        
        try
        {
            // 1. 재고 확인
            foreach (var item in request.Items)
            {
                var isAvailable = await inventoryService.CheckAvailabilityAsync(
                    item.ProductId, 
                    item.Quantity
                );
                
                if (!isAvailable)
                {
                    return OrderResult.Failure($"상품 {item.ProductId}의 재고가 부족합니다.");
                }
            }
            
            // 2. 주문 생성
            var order = new Order
            {
                CustomerId = request.CustomerId,
                Status = OrderStatus.Pending,
                CreatedAt = DateTime.UtcNow
            };
            
            foreach (var item in request.Items)
            {
                var product = await productRepository.GetByIdAsync(item.ProductId);
                order.Items.Add(new OrderItem
                {
                    ProductId = product.Id,
                    ProductName = product.Name,
                    Quantity = item.Quantity,
                    UnitPrice = product.Price
                });
            }
            
            // 3. 재고 예약
            foreach (var item in order.Items)
            {
                await inventoryService.ReserveStockAsync(item.ProductId, item.Quantity);
            }
            
            // 4. 결제 처리
            var paymentResult = await paymentService.ProcessPaymentAsync(
                order, 
                request.PaymentMethod
            );
            
            if (!paymentResult.IsSuccess)
            {
                // 결제 실패 시 재고 복구
                foreach (var item in order.Items)
                {
                    await inventoryService.ReleaseStockAsync(item.ProductId, item.Quantity);
                }
                
                return OrderResult.Failure("결제 처리에 실패했습니다.");
            }
            
            // 5. 주문 상태 업데이트 및 저장
            order.Status = OrderStatus.Paid;
            await orderRepository.AddAsync(order);
            
            // 6. 알림 발송
            await notificationService.SendOrderConfirmationAsync(order);
            
            logger.LogInformation($"주문 생성 완료: 주문번호 {order.Id}");
            
            return OrderResult.Success(order);
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "주문 생성 중 오류 발생");
            return OrderResult.Failure("주문 처리 중 오류가 발생했습니다.");
        }
    }
    
    public async Task<bool> CancelOrderAsync(int orderId)
    {
        var order = await orderRepository.GetByIdAsync(orderId);
        
        if (order == null)
            return false;
        
        if (order.Status == OrderStatus.Shipped || order.Status == OrderStatus.Delivered)
        {
            throw new InvalidOperationException("배송 중이거나 완료된 주문은 취소할 수 없습니다.");
        }
        
        // 재고 복구
        foreach (var item in order.Items)
        {
            await inventoryService.ReleaseStockAsync(item.ProductId, item.Quantity);
        }
        
        order.Status = OrderStatus.Cancelled;
        await orderRepository.UpdateAsync(order);
        
        return true;
    }
}

// ========== Infrastructure Layer (인프라 계층) ==========
// 실제 구현체

public class SqlProductRepository : IProductRepository
{
    private readonly DbContext dbContext;
    
    public SqlProductRepository(DbContext dbContext)
    {
        this.dbContext = dbContext;
    }
    
    public async Task<Product> GetByIdAsync(int id)
    {
        return await dbContext.Products.FindAsync(id);
    }
    
    // 다른 메서드 구현...
}

public class StripePaymentService : IPaymentService
{
    private readonly IConfiguration configuration;
    
    public StripePaymentService(IConfiguration configuration)
    {
        this.configuration = configuration;
    }
    
    public async Task<PaymentResult> ProcessPaymentAsync(Order order, PaymentMethod method)
    {
        // Stripe API를 통한 실제 결제 처리
        // ...
        return new PaymentResult { IsSuccess = true };
    }
}

public class EmailNotificationService : INotificationService
{
    private readonly IEmailService emailService;
    
    public EmailNotificationService(IEmailService emailService)
    {
        this.emailService = emailService;
    }
    
    public async Task SendOrderConfirmationAsync(Order order)
    {
        var subject = $"주문 확인 - 주문번호 {order.Id}";
        var body = $"주문이 정상적으로 처리되었습니다. 총 금액: {order.GetTotalAmount()}원";
        
        await emailService.SendEmailAsync(order.CustomerId, subject, body);
    }
    
    public async Task SendShippingNotificationAsync(Order order)
    {
        var subject = $"배송 시작 - 주문번호 {order.Id}";
        var body = "상품이 배송 시작되었습니다.";
        
        await emailService.SendEmailAsync(order.CustomerId, subject, body);
    }
}

// ========== Dependency Injection 설정 ==========

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Repository 등록
        services.AddScoped<IProductRepository, SqlProductRepository>();
        services.AddScoped<IOrderRepository, SqlOrderRepository>();
        
        // Service 등록
        services.AddScoped<OrderService>();
        services.AddScoped<IPaymentService, StripePaymentService>();
        services.AddScoped<INotificationService, EmailNotificationService>();
        services.AddScoped<IInventoryService, InventoryService>();
        
        // Infrastructure
        services.AddDbContext<DbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))
        );
        
        services.AddControllers();
    }
}