개발원칙) DRY 개발원칙 (Don't Repeat Yourself)

 DRY 개발원칙 (Don't Repeat Yourself)

소프트웨어 개발에서 중복을 피하고 효율성을 높이기 위한 원칙을 나타냅니다.

이 원칙은 코드의 중복을 최소화하고 모듈화된, 재사용 가능한 코드를 작성하라는 것을 강조합니다. 중복된 코드는 유지보수를 어렵게 하고 버그를 발생시킬 가능성을 높입니다.

DRY 원칙을 따르려면, 비슷한 기능이나 작업을 하는 코드가 여러 곳에 중복되지 않도록 해야 합니다. 대신, 공통된 동작을 하는 코드를 함수, 클래스, 또는 모듈로 추상화하여 재사용할 수 있도록 해야 합니다.

이 원칙은 코드의 일관성을 유지하고 업데이트 및 수정이 필요한 경우 한 곳에서만 수정하면 되기 때문에 생산성을 향상시키고 실수를 줄일 수 있습니다.

 

반응형

 

< Singleton Pattern >

단일 인스턴스만을 갖도록 보장하는 패턴입니다.
중복된 인스턴스 생성을 방지하고, 전역적으로 해당 인스턴스에 접근할 수 있습니다.

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

 

< Factory Pattern >

객체 생성을 캡슐화하고, 클라이언트 코드에서 구체적인 클래스에 의존하지 않도록 하는 패턴입니다.

interface IProduct
{
    void Operation();
}

class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation in ConcreteProductA");
    }
}

class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation in ConcreteProductB");
    }
}

class ProductFactory
{
    public IProduct CreateProduct(string productType)
    {
        switch (productType)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid product type");
        }
    }
}

 

 

< Observer Pattern >

Observer 패턴은 어떤 객체의 상태 변화를 관찰하고, 해당 변화에 대응하여 다른 객체들에게 알리는 패턴입니다.

 

using System;

// 주제(Subject) 인터페이스
public interface ISubject
{
    void Attach(IObserver observer); // 관찰자 추가
    void Detach(IObserver observer); // 관찰자 제거
    void Notify(); // 상태 변경 알림
}

// 관찰자(Observer) 인터페이스
public interface IObserver
{
    void Update(ISubject subject); // 주제의 상태 업데이트
}

using System;
using System.Collections.Generic;

// 구체적인 주제 클래스
public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();
    private int state;

    public int State
    {
        get { return state; }
        set
        {
            state = value;
            Notify(); // 상태 변경 시 관찰자들에게 알림
        }
    }

    public void Attach(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in observers)
        {
            observer.Update(this);
        }
    }
}

// 구체적인 관찰자 클래스
public class ConcreteObserver : IObserver
{
    private string name;

    public ConcreteObserver(string name)
    {
        this.name = name;
    }

    public void Update(ISubject subject)
    {
        Console.WriteLine($"{name} received notification: Subject's state is {((ConcreteSubject)subject).State}");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        // 주제 생성
        ConcreteSubject subject = new ConcreteSubject();

        // 관찰자 생성
        ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
        ConcreteObserver observer2 = new ConcreteObserver("Observer 2");

        // 관찰자 주제에 연결
        subject.Attach(observer1);
        subject.Attach(observer2);

        // 상태 변경 시 관찰자들에게 알림
        subject.State = 10;
        subject.State = 20;

        // 관찰자 주제에서 분리
        subject.Detach(observer2);

        // 다시 상태 변경 시 관찰자들에게 알림
        subject.State = 30;

        Console.ReadLine();
    }
}

asd

 

★☆☆☆☆