[CS] 디자인 패턴 간단 정리

디자인패턴 (Design Pattern)

• 프로그램을 설계할 때 발생했던 문제점들을 객체 간의 상호 관계를 이용하여 해결할 수 있도록 하나의 "규약" 형태로 만들어 놓은 것을 의미
• 쉽게 말해 지금까지 프로그래밍을 하던 사람들이 이런 상황에서는 ~~ 한 패턴을 쓰는 게 좋더라 식으로 먼저 깨닫고 정립하여 후대들에게 추천하는 일종의 방법론이기도 하다. 

 

1. 싱글톤 패턴 (Singleton Pattern)

• 하나의 클래스에 오직 하나의 인스턴스만을 가지는(보장하는) 패턴
• 보통 데이터 베이스 연결 모듈에 많이 사용한다. 
• 단점으로는 하나의 인스턴스만 보기 때문에 의존성이 높아진다.
  • 이 단점의 해결방법중 하나는 의존성 주입(DI, Dependency Injection)이다.
  • 이는 메인 모듈 (싱글톤 클래스)에서 직접 하위 모듈에 대한 의존성을 주지 않고 중간에 의존성 주입자가 이 부분을 가로채 메인 모듈이 간접적으로 의존성을 주입시키는 방법이 있다.
  • 물론 이 방법도 단점이 있는데 이는 모듈이 더욱 분리되어 클래스가 늘어나기 때문에 복잡성이 증가될 수 있고 약간의 런타임 페널티가 생길 수 있다.

 

2.  팩토리 패턴 (Factory Pattern)

• 객체를 사용하는 코드에서 객체 생성 부분을 떼어내 추상화한 패턴.
• 상속관계에 있는 두 클래스에서 상위 클래스가 중요한 뼈대를 결정하고 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴이다.
• 상위, 하위 클래스가 분리되기 때문에 두 클래스 간의 결합이 느슨해진다는 장점이 있다. (상위 클래스에서 하위 클래스의 구현부를 알지 않아도 되기 때문) = 코드 유지보수가 간단해진다.

3. 전략 패턴 (Strategy pattern) 혹은 정책 패터 (policy pattern)

• 객체의 행위를 바꾸고 싶을 때 직접 수정하지 않고 전략이라고 부르는 캡슐화한 알고리즘을 콘텍스트 안에서 바꿔주면서 상호 교체가 가능하게 하는 패턴 
• 쉽게 말해 객체의 기능들을 변경할 때 해당 객체가 사용할 수 있는 기능들을 인터페이스로 분리해 관리하며 기능부만 수정해 주는 방식으로 사용이 가능하다.
• 예시

// 전략 인터페이스
public interface ISortStrategy
{
    void Sort(List<int> list);
}

// 구체적인 전략 클래스들
public class QuickSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("QuickSort");
        // 실제 정렬 알고리즘 구현
    }
}

public class MergeSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("MergeSort");
        // 실제 정렬 알고리즘 구현
    }
}

// 컨텍스트 클래스
public class SortContext
{
    private ISortStrategy _sortStrategy;

    public SortContext(ISortStrategy sortStrategy)
    {
        _sortStrategy = sortStrategy;
    }

    public void SetSortStrategy(ISortStrategy sortStrategy)
    {
        _sortStrategy = sortStrategy;
    }

    public void SortList(List<int> list)
    {
        _sortStrategy.Sort(list);
    }
}

// 클라이언트 코드
class Program
{
    static void Main()
    {
        List<int> myList = new List<int> { 4, 2, 8, 1, 5 };

        SortContext context = new SortContext(new QuickSort());
        context.SortList(myList);

        context.SetSortStrategy(new MergeSort());
        context.SortList(myList);
    }
}

 

5. 옵저버 패턴 (Observer Pattern)

• 주체가 어떤 객체의 상태 변화를 관찰하다 상태 변화가 있을 때마다 메서드 등을 통해 옵저버 목록에 있는 옵저버 (리스너) 들에게 Callback 해주는 디자인 패턴.
• 주로 이벤트 기반 시스템에 사용한다.
• MVC 패턴과 목적과 적용 분야에서 비슷하지만 엄연히 다른 패턴이다. (필자도 MVC패턴이 먼저 생각났다.)

 

6. 프록시 패턴 (Proxy Pattern)

• 대상 객체에 접근하기 전 그 접근에 대한 흐름을 가로채 대상 객체 앞단의 인터페이스 역할을 하는 패턴.
• 객체속성, 변환등을 보완하며 보안, 데이터 검증, 캐싱, 로깅에 사용한다.
• 예시

using System;

// 실제 이미지 로딩을 담당하는 실제 서비스
public interface IImage
{
    void Display();
}

// 실제 이미지 로딩 서비스의 구현
public class RealImage : IImage
{
    private string _filename;

    public RealImage(string filename)
    {
        _filename = filename;
        LoadImageFromDisk();
    }

    private void LoadImageFromDisk()
    {
        Console.WriteLine($"Loading image from disk: {_filename}");
    }

    public void Display()
    {
        Console.WriteLine($"Displaying image: {_filename}");
    }
}

// 프록시 역할을 하는 가상 이미지 로딩 서비스
public class ProxyImage : IImage
{
    private RealImage _realImage;
    private string _filename;

    public ProxyImage(string filename)
    {
        _filename = filename;
    }

    public void Display()
    {
        if (_realImage == null)
        {
            _realImage = new RealImage(_filename);
        }
        _realImage.Display();
    }
}

// 클라이언트 코드
class Program
{
    static void Main()
    {
        // 클라이언트가 직접 RealImage를 생성하지 않고 ProxyImage를 사용
        IImage image = new ProxyImage("example.jpg");

        // 이미지를 처음 로딩할 때만 실제 이미지 로딩 서비스를 생성하고 사용
        image.Display();

        // 이미지를 두 번째로 로딩할 때에는 이미 로딩된 RealImage를 사용
        image.Display();
    }
}

7. 이터레이터 패턴 (Iterator Pattern)

• 반복자를 사용하여 컬렉션의 요소들에 접근하는 디자인 패턴
• 순회할수 있는 여러가지 자료형의 상세 구조를 알필요 없이 이터레이터 인터페이스 하나로 순회 가능하게 만들어준다. = 한마디로 여러 자료형을 순회하며 탐색할수 있는 만능 도구를 만든다 생각하면 된다.
• 예시

using System;
using System.Collections;

// 이터레이터 인터페이스
public interface IIterator
{
    bool HasNext();
    object Next();
}

// 컬렉션 인터페이스
public interface IAggregate
{
    IIterator CreateIterator();
}

// 구체적인 이터레이터 클래스
public class MyIterator : IIterator
{
    private ArrayList _items;
    private int _position = 0;

    public MyIterator(ArrayList items)
    {
        _items = items;
    }

    public bool HasNext()
    {
        return _position < _items.Count;
    }

    public object Next()
    {
        if (HasNext())
        {
            object currentItem = _items[_position];
            _position++;
            return currentItem;
        }
        else
        {
            return null;
        }
    }
}

// 구체적인 컬렉션 클래스
public class MyCollection : IAggregate
{
    private ArrayList _items = new ArrayList();

    public void AddItem(object item)
    {
        _items.Add(item);
    }

    public IIterator CreateIterator()
    {
        return new MyIterator(_items);
    }
}

// 클라이언트 코드
class Program
{
    static void Main()
    {
        MyCollection collection = new MyCollection();
        collection.AddItem("Item 1");
        collection.AddItem("Item 2");
        collection.AddItem("Item 3");

        IIterator iterator = collection.CreateIterator();

        while (iterator.HasNext())
        {
            object currentItem = iterator.Next();
            Console.WriteLine(currentItem);
        }
    }
}

 

8. 노출모듈 패턴

• 즉시 실행 함수를 통해 private public 같은 접근 제어자를 만드는 패턴이다.
• 이미 c$에서는 접근 제어자를 제공하기 때문에 패턴 그대로는 잘 사용하지 않는다.

9. MVC 패턴

• 모델(Model) 뷰(view) 콘트롤러 (Controller) 로 이루어진 디자인 패턴
• 상위 구성 요소로 구분하여 개발 프로세스에서 각각의 구성 요소에만 집중하여 개발할수 있도록 해주는 패턴
• 재사용과 확정성이 유용하지만 해당 애플리케이션이 복잡해질수록 모델과 뷰의 관계가 복잡해진다는 단점이 있다.
• 각각의 항목을 나누어 정리해보면
  • 모델
    • 데이터, 데이터 베이스, 상수, 변수등을 나타낸다.
    • 게임에서는 게임데이터 (서버에서 가져오는 게임의 raw 데이터 등이 예시가 될 수 있겠다.)
  • 뷰
    • 사용자의 인터페이스를 나타낸다
    • 게임에서는 UI등의 사용자 인터페이스 등이 좋은 예시가 되겠다.
  • 컨트롤러
    • 하나 이상의 모델과 하나이상의 뷰를 잇는 다리역할로 이벤트의 구현부 등 메인 로직을 담당한다.
    • 모델과 뷰의 생명주기도 관리하며 모델이나 뷰의 변경 통지를 받으면 이를 해석하여 각각의 구성 요소에 해당 내용을 전달하는 역할이다.