SOLID 원칙에 관하여

using System;
using System.Data.SqlClient;

public class Employee_BadExample // 클래스명으로 BadExample임을 명시
{
    public string Name { get; set; }
    public double BaseSalary { get; set; }
    public string Department { get; set; }

    private SqlConnection dbConnection; // Employee 클래스가 데이터베이스 연결까지 담당하고 있다

    public Employee_BadExample(string name, double baseSalary, string department, SqlConnection dbConnection)
    {
        Name = name;
        BaseSalary = baseSalary;
        Department = department;
        this.dbConnection = dbConnection; // Employee 클래스가 데이터베이스 연결 객체를 받는다
    }

    public double CalculateSalary()
    {
        // 급여 계산 메서드 (부서마다 다른 보너스 비율을 가정)
        double bonusRate = 0;
        if (Department == "Sales")
        {
            bonusRate = 0.1;
        }
        else if (Department == "Marketing")
        {
            bonusRate = 0.05;
        }
        return BaseSalary * (1 + bonusRate);
    }

    public void SaveToDatabase()
    {
        // 직원 정보를 데이터베이스에 저장하는 메서드
        double salary = CalculateSalary(); // 급여 계산 로직이 Employee 내부에 있다
        try
        {
            dbConnection.Open();
            SqlCommand command = new SqlCommand(
                "INSERT INTO Employees (Name, Salary, Department) VALUES (@Name, @Salary, @Department)",
                dbConnection);
            command.Parameters.AddWithValue("@Name", Name);
            command.Parameters.AddWithValue("@Salary", salary);
            command.Parameters.AddWithValue("@Department", Department);
            command.ExecuteNonQuery();
        }
        catch (Exception ex)
        {
            Console.WriteLine("데이터베이스 저장 오류: " + ex.Message);
        }
        finally
        {
            dbConnection.Close();
        }
    }
}

public class BadExample_Program // BadExample을 사용하는 메인 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 잘못된 예시: Employee_BadExample 클래스가 너무 많은 책임을 지고 있다
        SqlConnection dbConn = null; // 실제 데이터베이스 연결 객체로 교체 필요 (여기서는 null로 대체)
        Employee_BadExample employee = new Employee_BadExample("홍길동", 3000000, "Sales", dbConn);
        employee.SaveToDatabase(); // Employee_BadExample이 급여 계산과 데이터베이스 저장을 모두 담당한다
    }
}

using System;
using System.Data.SqlClient;

public class Employee // Employee 클래스는 데이터만 담당한다
{
    public string Name { get; set; }
    public double BaseSalary { get; set; }
    public string Department { get; set; }

    public Employee(string name, double baseSalary, string department)
    {
        Name = name;
        BaseSalary = baseSalary;
        Department = department;
    }
}

public class SalaryCalculator // 급여 계산을 담당하는 클래스
{
    public double CalculateSalary(Employee employee) // Employee 객체를 매개변수로 받는다
    {
        // 급여 계산 메서드
        double bonusRate = 0;
        if (employee.Department == "Sales")
        {
            bonusRate = 0.1;
        }
        else if (employee.Department == "Marketing")
        {
            bonusRate = 0.05;
        }
        return employee.BaseSalary * (1 + bonusRate);
    }
}

public class EmployeeRepository // 데이터베이스 저장을 담당하는 클래스
{
    private SqlConnection dbConnection;

    public EmployeeRepository(SqlConnection dbConnection)
    {
        this.dbConnection = dbConnection;
    }

    public void Save(Employee employee, double salary) // Employee 객체와 계산된 급여를 받는다
    {
        // 직원 정보를 데이터베이스에 저장하는 메서드
        try
        {
            dbConnection.Open();
            SqlCommand command = new SqlCommand(
                "INSERT INTO Employees (Name, Salary, Department) VALUES (@Name, @Salary, @Department)",
                dbConnection);
            command.Parameters.AddWithValue("@Name", employee.Name);
            command.Parameters.AddWithValue("@Salary", salary);
            command.Parameters.AddWithValue("@Department", employee.Department);
            command.ExecuteNonQuery();
        }
        catch (Exception ex)
        {
            Console.WriteLine("데이터베이스 저장 오류: " + ex.Message);
        }
        finally
        {
            dbConnection.Close();
        }
    }
}

public class GoodExample_Program // GoodExample을 사용하는 메인 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 올바른 예시: 각 클래스가 단일 책임만 진다
        SqlConnection dbConn = null; // 실제 데이터베이스 연결 객체로 교체 필요
        Employee employee = new Employee("김철수", 3500000, "Marketing");
        SalaryCalculator calculator = new SalaryCalculator(); // 급여 계산 담당 객체 생성
        double salary = calculator.CalculateSalary(employee);
        EmployeeRepository repository = new EmployeeRepository(dbConn); // 데이터베이스 저장 담당 객체 생성
        repository.Save(employee, salary);
    }
}

using System;

public class PaymentProcessor_BadExample // 클래스명으로 BadExample임을 명시
{
    public void ProcessPayment(string paymentMethod, double amount)
    {
        // 결제 방식에 따라 처리하는 메서드 (if-else 문을 대량으로 사용)
        if (paymentMethod == "Card")
        {
            // 신용카드 결제 처리 로직
            Console.WriteLine($"신용카드로 {amount}원 결제");
        }
        else if (paymentMethod == "Cash")
        {
            // 현금 결제 처리 로직
            Console.WriteLine($"현금으로 {amount}원 결제");
        }
        else if (paymentMethod == "MobilePay") // 새로운 결제 방식 추가 시 코드를 수정해야 한다
        {
            // 모바일 결제 처리 로직
            Console.WriteLine($"모바일 결제로 {amount}원 결제");
        }
        else
        {
            Console.WriteLine("지원하지 않는 결제 방식");
        }
    }
}

public class BadExample_Program // BadExample을 사용하는 메인 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 잘못된 예시: PaymentProcessor_BadExample은 OCP를 위반하며, 쉽게 확장할 수 없다
        PaymentProcessor_BadExample processor = new PaymentProcessor_BadExample();
        processor.ProcessPayment("Card", 10000);
        processor.ProcessPayment("Cash", 5000);
        processor.ProcessPayment("MobilePay", 7000); // 새로운 결제 방식 사용
    }
}

using System;

// IPayment 인터페이스: 모든 결제 방식에 적용되는 공통 인터페이스
public interface IPayment
{
    void ProcessPayment(double amount);
}

// 신용카드 결제 클래스 (IPayment 구현)
public class CardPayment : IPayment
{
    public void ProcessPayment(double amount)
    {
        Console.WriteLine($"[신용카드 결제] {amount:N0}원 결제 완료");
    }
}

// 현금 결제 클래스 (IPayment 구현)
public class CashPayment : IPayment
{
    public void ProcessPayment(double amount)
    {
        Console.WriteLine($"[현금 결제] {amount:N0}원 결제 완료");
    }
}

// 모바일 결제 클래스 (IPayment 구현)
public class MobilePayPayment : IPayment
{
    public void ProcessPayment(double amount)
    {
        Console.WriteLine($"[모바일 결제] {amount:N0}원 결제 완료");
    }
}

// 결제 처리 클래스: OCP를 준수한다
public class PaymentProcessor
{
    private readonly IPayment paymentMethod;

    // 생성자를 통해 결제 방식을 주입한다 (의존성 주입 DI 적용 가능)
    public PaymentProcessor(IPayment paymentMethod)
    {
        this.paymentMethod = paymentMethod ?? throw new ArgumentNullException(nameof(paymentMethod));
    }

    public void Process(double amount)
    {
        paymentMethod.ProcessPayment(amount);
    }
}

public class Program
{
    public static void Main()
    {
        // 각 결제 방식 객체 생성
        var cardPayment = new CardPayment();
        var cashPayment = new CashPayment();
        var mobilePayPayment = new MobilePayPayment();

        // OCP 준수: 새로운 결제 방식 추가 시 PaymentProcessor 코드를 수정할 필요가 없다
        var processor1 = new PaymentProcessor(cardPayment);
        processor1.Process(10000);

        var processor2 = new PaymentProcessor(cashPayment);
        processor2.Process(5000);

        var processor3 = new PaymentProcessor(mobilePayPayment);
        processor3.Process(7000);
    }
}

public class Bird
{
    public virtual void Fly() => Console.WriteLine("새가 날고 있다.");
}

public class Penguin : Bird
{
    public override void Fly() // 펭귄은 날 수 없다
    {
        throw new NotImplementedException("펭귄은 날 수 없다.");
    }
}

public class Program
{
    public static void MakeBirdFly(Bird bird)
    {
        bird.Fly(); // Penguin 객체가 전달되면 예외가 발생한다
    }

    static void Main()
    {
        Bird myBird = new Penguin();
        MakeBirdFly(myBird); // 프로그램이 중단될 수 있다
    }
}

// Bird를 추상화하여 직접 사용하지 않는다
public abstract class Bird { }

// 비행 인터페이스 정의
public interface IFlyable
{
    void Fly();
}

// 참새 클래스 (IFlyable 인터페이스 구현)
public class Sparrow : Bird, IFlyable
{
    public void Fly() => Console.WriteLine("참새가 날고 있다.");
}

// 펭귄 클래스 (IFlyable 인터페이스를 구현하지 않아 날 수 없음을 표현한다)
public class Penguin : Bird { }

public class Program
{
    public static void MakeBirdFly(IFlyable bird)
    {
        bird.Fly();
    }

    static void Main()
    {
        IFlyable sparrow = new Sparrow();
        MakeBirdFly(sparrow); // 정상 실행
    }
}

using System;

// IWorker_BadExample 인터페이스: 너무 많은 기능을 포함하고 있다 (ISP 위반)
public interface IWorker_BadExample
{
    void Work();   // 작업 기능
    void Eat();    // 식사 기능 - 하지만 Robot에게는 불필요하다
}

// Robot_BadExample 클래스: IWorker_BadExample을 구현하므로 불필요한 Eat() 메서드를 강제로 구현해야 한다
public class Robot_BadExample : IWorker_BadExample
{
    public void Work()
    {
        Console.WriteLine("로봇이 열심히 작업하고 있다.");
    }

    public void Eat() // 로봇은 식사가 필요 없지만 구현해야만 한다
    {
        // 로봇은 식사를 하지 않으므로 아무것도 하지 않거나 예외를 던질 수밖에 없다
        Console.WriteLine("로봇은 식사를 할 수 없다."); // 또는 throw new NotImplementedException();
    }
}

// HumanWorker_BadExample 클래스: IWorker_BadExample을 구현하며 Work()와 Eat()을 올바르게 구현한다
public class HumanWorker_BadExample : IWorker_BadExample
{
    public void Work()
    {
        Console.WriteLine("인간이 열심히 작업하고 있다.");
    }

    public void Eat()
    {
        Console.WriteLine("인간이 점심을 먹고 있다.");
    }
}

public class BadExample_Program // BadExample을 사용하는 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 잘못된 예시: Robot_BadExample은 Eat() 메서드를 가져서는 안 된다
        IWorker_BadExample robot = new Robot_BadExample();
        robot.Work();
        robot.Eat(); // 로봇이 Eat() 메서드를 호출하는 것은 어색하다

        IWorker_BadExample human = new HumanWorker_BadExample();
        human.Work();
        human.Eat();
    }
}

using System;

// IWorkable 인터페이스: 작업 기능만 포함한다 (ISP 준수)
public interface IWorkable
{
    void Work(); // 작업 기능
}

// IEatable 인터페이스: 식사 기능만 포함한다 (ISP 준수)
public interface IEatable
{
    void Eat(); // 식사 기능
}

// Robot_GoodExample 클래스: IWorkable 인터페이스만 구현한다 (필요한 기능만 구현)
public class Robot_GoodExample : IWorkable // 로봇은 작업만 할 수 있다
{
    public void Work()
    {
        Console.WriteLine("로봇이 효율적으로 작업을 수행한다.");
    }

    // Eat() 미구현: 로봇은 식사가 필요 없다
}

// HumanWorker_GoodExample 클래스: IWorkable과 IEatable 인터페이스를 모두 구현한다 (필요한 기능을 모두 보유)
public class HumanWorker_GoodExample : IWorkable, IEatable // 인간은 작업도 하고 식사도 할 수 있다
{
    public void Work()
    {
        Console.WriteLine("인간이 창의적으로 작업한다.");
    }

    public void Eat()
    {
        Console.WriteLine("인간이 맛있는 점심을 즐기고 있다.");
    }
}

public class GoodExample_Program // GoodExample을 사용하는 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 올바른 예시: Robot_GoodExample은 IWorkable만 구현하면 된다
        IWorkable robot = new Robot_GoodExample(); // 로봇은 IWorkable 타입으로만 사용된다
        robot.Work();
        // robot.Eat(); // Robot은 IEatable을 구현하지 않으므로 Eat() 호출 불가 (컴파일 오류)

        IWorkable humanWorker = new HumanWorker_GoodExample(); // HumanWorker는 IWorkable 타입으로 사용 가능
        humanWorker.Work();

        IEatable humanEater = new HumanWorker_GoodExample(); // HumanWorker는 IEatable 타입으로도 사용 가능
        humanEater.Eat();
    }
}

using System;

// SqlDatabase 클래스: 구체적인 데이터베이스 구현체 (저수준 모듈, 특정 데이터베이스에 직접 의존한다)
public class SqlDatabase_BadExample
{
    public void Save(string data)
    {
        // 실제로 SqlDatabase에 데이터를 저장하는 로직 (구현 생략)
        Console.WriteLine($"SqlDatabase에 데이터 저장 완료: {data}");
    }
}

// OrderService_BadExample 클래스: SqlDatabase에 직접 의존한다 (DIP 위반, 고수준 모듈)
public class OrderService_BadExample
{
    private SqlDatabase_BadExample database; // 구체적인 SqlDatabase 클래스에 직접 의존한다

    public OrderService_BadExample()
    {
        database = new SqlDatabase_BadExample(); // OrderService가 SqlDatabase 인스턴스를 직접 생성한다
    }

    public void PlaceOrder(string orderData)
    {
        // 주문 처리 로직 (여기서는 단순히 데이터를 저장한다)
        Console.WriteLine($"주문 처리 중: {orderData}");
        database.Save(orderData); // OrderService가 SqlDatabase의 Save() 메서드를 직접 호출한다
        Console.WriteLine("주문 처리 완료");
    }
}

public class BadExample_Program // BadExample을 사용하는 프로그램 클래스
{
    public static void Main(string[] args)
    {
        // 잘못된 예시: OrderService_BadExample이 SqlDatabase와 강하게 결합되어 있어 확장이 어렵다
        OrderService_BadExample service = new OrderService_BadExample();
        service.PlaceOrder("고객: 홍길동, 상품: 노트북");
    }
}

using System;

// DIP(의존 역전 원칙) 준수: OrderService는 IDatabase 인터페이스에만 의존한다
public interface IDatabase
{
    void SaveOrder(string orderDetails);
}

// SqlDatabase가 IDatabase 인터페이스를 구현한다
public class SqlDatabase : IDatabase
{
    public void SaveOrder(string orderDetails)
    {
        Console.WriteLine($"[SqlDatabase] 주문 저장 완료: {orderDetails}");
    }
}

// MongoDatabase가 IDatabase 인터페이스를 구현한다 (새로운 데이터베이스 타입을 추가할 수 있다)
public class MongoDatabase : IDatabase
{
    public void SaveOrder(string orderDetails)
    {
        Console.WriteLine($"[MongoDatabase] 주문 저장 완료: {orderDetails}");
    }
}

// OrderService는 구체적인 구현체가 아닌 인터페이스(IDatabase)에 의존한다
public class OrderService
{
    private readonly IDatabase database;

    // DIP(의존 역전 원칙): OrderService는 구체적인 구현체가 아닌 인터페이스에 의존한다
    public OrderService(IDatabase database)
    {
        this.database = database; // 의존성 주입 (Dependency Injection)
    }

    public void PlaceOrder(string orderDetails)
    {
        database.SaveOrder(orderDetails); // 인터페이스를 통해 주문을 저장한다
    }
}

// OrderService가 특정 데이터베이스에 의존하지 않으므로 데이터베이스를 쉽게 교체할 수 있다
public class Program
{
    public static void Main()
    {
        // DI 컨테이너 없이 객체를 직접 생성하여 의존성을 주입한다
        IDatabase sqlDatabase = new SqlDatabase();
        IDatabase mongoDatabase = new MongoDatabase();

        // SqlDatabase를 사용하는 OrderService
        OrderService orderService1 = new OrderService(sqlDatabase);
        orderService1.PlaceOrder("상품 A 주문");

        // MongoDatabase를 사용하는 OrderService
        OrderService orderService2 = new OrderService(mongoDatabase);
        orderService2.PlaceOrder("상품 B 주문");
    }
}