2024년 6월 25일 화요일 개발일지 / 팩토리 패턴에 대해서

2024년 6월 25일 화요일

---

What I did today

 

 

오늘 오전에는 팀원분들 다 같이 온라인 구글 문서 프레젠테이션으로 결과보고서를 작성했습니다. 일단 다들 자체 평가에 대해서 쓰고, 프로젝트 개요나 수행 절차 등등 다 같이 이야기를 통해서 적어야 하는 것들은 회의를 통해서 이야기를 나누어 내용을 채워나갔습니다. 점심을 먹은 뒤에는 제가 최종적으로 결과보고서를 다운 받아서 폰트 정리와 디자인 정리를 했고, 팀원분들에게 공유를 했습니다.

 

 

그리고 할게 뭐 없나 하다가 저희 게임의 UI 디자인이 뒤죽박죽이라 폰트랑 UI를 통일하는 작업을 진행했습니다. 최대한 깔끔하게 보이게끔 만드는데 노력했고, 생각한 것보다 디자인이 잘 나온 것 같아 만족합니다. 디자인 작업이 끝나고 저녁을 먹은 뒤, 최종적으로 팀원분들이랑 같이 보스 보상 로직이나 패배 로직 등등 추가하고 빌드함으로써 프로젝트를 일단 마무리하게 됐습니다. 남은 시간에는 시연 영상 담당하시는 분이 작업을 진행하시고 나머지 분들은 같이 이야기를 하면서 TIL 썼고, 오늘 하루를 마무리했습니다. 이번 내용은 저번 옵저버 패턴에 이어서 팩토리 패턴에 대해서 써볼까 합니다.

---

팩토리 패턴에 대해서

 

팩토리 패턴 (Factory Pattern) 이란?

 

팩토리 패턴(Factory Pattern)은 객체 생성의 인스턴스화를 서브 클래스에 맡기는 디자인 패턴이다. 이 패턴을 사용하면 객체 생성의 구체적인 클래스를 직접 사용하지 않고, 객체를 생성할 때 어떤 클래스의 인스턴스를 생성할지를 결정하는 클래스를 통해 객체를 생성한다. 이는 객체 생성의 유연성을 높이고 코드의 재사용성을 증가시킨다.

---

팩토리 메소드 패턴 (Factory Method Pattern)

 

팩토리 메소드메서드 패턴은 상속을 통해 객체를 생성하는 디자인 패턴이다. 상위 클래스는 팩토리 메서드를 선언하고, 하위 클래스가 이를 구현하여 인스턴스를 생성한다. 다음은 C#으로 팩토리 메소드 패턴을 구현한 예제입니다.

using System;

namespace FactoryMethodPattern
{
    // Product 인터페이스
    public interface IProduct
    {
        void Display();
    }

    // ConcreteProductA 클래스
    public class ConcreteProductA : IProduct
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductA");
        }
    }

    // ConcreteProductB 클래스
    public class ConcreteProductB : IProduct
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductB");
        }
    }

    // Creator 추상 클래스
    public abstract class Creator
    {
        // 팩토리 메소드
        public abstract IProduct FactoryMethod();

        public void AnOperation()
        {
            var product = FactoryMethod();
            product.Display();
        }
    }

    // ConcreteCreatorA 클래스
    public class ConcreteCreatorA : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ConcreteProductA();
        }
    }

    // ConcreteCreatorB 클래스
    public class ConcreteCreatorB : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ConcreteProductB();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Creator creatorA = new ConcreteCreatorA();
            creatorA.AnOperation();

            Creator creatorB = new ConcreteCreatorB();
            creatorB.AnOperation();
        }
    }
}

 

위 코드에서는 IProduct 인터페이스를 정의하고, 이를 구현하는 ConcreteProductA와 ConcreteProductB 클래스를 생성한다. Creator 추상 클래스는 FactoryMethod라는 추상 메서드를 포함하고 있으며, ConcreteCreatorA와 ConcreteCreatorB 클래스에서 이를 구현하여 각기 다른 제품을 생성한다.

---

추상 팩토리 패턴 (Abstract Factory Pattern)

 

추상 팩토리 패턴은 서로 관련된 객체들의 집합을 생성하는 인터페이스를 제공하는 패턴이다. 구체적인 클래스는 사용자에게 감추고, 다양한 제품군을 생성하는 인터페이스를 제공한다. 다음은 C#으로 추상 팩토리 패턴을 구현한 예제이다.

 

using System;

namespace AbstractFactoryPattern
{
    // ProductA 인터페이스
    public interface IProductA
    {
        void Display();
    }

    // ProductB 인터페이스
    public interface IProductB
    {
        void Display();
    }

    // ConcreteProductA1 클래스
    public class ConcreteProductA1 : IProductA
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductA1");
        }
    }

    // ConcreteProductA2 클래스
    public class ConcreteProductA2 : IProductA
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductA2");
        }
    }

    // ConcreteProductB1 클래스
    public class ConcreteProductB1 : IProductB
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductB1");
        }
    }

    // ConcreteProductB2 클래스
    public class ConcreteProductB2 : IProductB
    {
        public void Display()
        {
            Console.WriteLine("ConcreteProductB2");
        }
    }

    // AbstractFactory 인터페이스
    public interface IAbstractFactory
    {
        IProductA CreateProductA();
        IProductB CreateProductB();
    }

    // ConcreteFactory1 클래스
    public class ConcreteFactory1 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ConcreteProductA1();
        }

        public IProductB CreateProductB()
        {
            return new ConcreteProductB1();
        }
    }

    // ConcreteFactory2 클래스
    public class ConcreteFactory2 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ConcreteProductA2();
        }

        public IProductB CreateProductB()
        {
            return new ConcreteProductB2();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IAbstractFactory factory1 = new ConcreteFactory1();
            IProductA productA1 = factory1.CreateProductA();
            IProductB productB1 = factory1.CreateProductB();
            productA1.Display();
            productB1.Display();

            IAbstractFactory factory2 = new ConcreteFactory2();
            IProductA productA2 = factory2.CreateProductA();
            IProductB productB2 = factory2.CreateProductB();
            productA2.Display();
            productB2.Display();
        }
    }
}

 

위 예제에서는 IProductA와 IProductB 인터페이스를 정의하고, 이를 구현하는 여러 제품 클래스들을 생성한다. IAbstractFactory 인터페이스는 제품군을 생성하는 메소드를 선언하고, ConcreteFactory1과 ConcreteFactory2 클래스에서 이를 구현하여 각기 다른 제품군을 생성한다.

 

팩토리 패턴을 사용하면 코드의 결합도를 낮추고, 확장성 및 유지보수성을 높일 수 있다. 특히, 객체 생성 로직이 복잡하거나 생성되는 객체가 여러 종류일 때 유용하다.