C# 팩토리 패턴 (Factory Pattern)

팩토리패턴?

팩토리 패턴 ( Factory Pattern )

정의

팩토리 패턴은 객체 생성의 인스턴스화 로직을 별도의 클래스나 메서드로 분리하여 객체 생성을 캡슐화하는 디자인 패턴입니다. 이를 통해 클라이언트 코드가 객체 생성의 구체적인 클래스에 의존하지 않게 하고, 객체 생성의 로직을 재사용할 수 있게 합니다.

개요

팩토리 패턴은 객체 지향 프로그래밍에서 객체 생성을 별도의 클래스나 메서드로 분리하여 객체 생성의 책임을 캡슐화하는 생성 패턴입니다. 이를 통해 클라이언트 코드가 구체적인 클래스에 의존하지 않고, 인터페이스를 통해 객체를 생성하도록 합니다. 팩토리 패턴은 객체 생성을 중앙에서 관리하며, 객체 생성 로직의 변경이 필요할 때 클라이언트 코드를 수정하지 않아도 되도록 유연성을 제공합니다. 또한, 코드의 재사용성을 높이고, 객체 생성의 복잡성을 감추어 가독성을 향상시킵니다. 팩토리 패턴은 확장성을 높이고 유지보수를 용이하게 하여, 대규모 소프트웨어 개발에서 특히 유용합니다.

팩토리 패턴은 크게 세 가지로 나눌 수 있지만, 기본적으로는 같습니다.

• 단순 팩토리 패턴 (Simple Factory Pattern) : 객체 생성을 단일 팩토리 클래스에서 처리합니다. 엄밀히 말하면 이는 디자인 패턴으로 간주되지 않지만, 팩토리 패턴의 기본 아이디어를 이해하는 데 도움이 됩니다.
• 팩토리 메서드 패턴 (Factory Method Pattern) : 객체 생성을 서브클래스에서 처리할 수 있도록 추상화된 메서드를 사용합니다. 클라이언트는 구체적인 클래스가 아닌 추상 클래스나 인터페이스를 통해 객체를 생성합니다.
• 추상 팩토리 패턴 (Abstract Factory Pattern) : 관련 객체의 군을 생성하기 위한 인터페이스를 제공합니다. 클라이언트는 구체적인 클래스가 아닌 팩토리를 통해 객체를 생성합니다.

팩토리 패턴 장점 및 단점

장점

• 객체 생성의 캡슐화 : 객체 생성의 세부 사항을 클라이언트로부터 숨길 수 있어 코드의 가독성이 향상됩니다.
• 확장성 : 새로운 제품을 추가할 때 클라이언트 코드를 수정하지 않고 팩토리 클래스를 수정하면 되므로 확장이 용이합니다.
• 코드 재사용성 : 객체 생성 로직을 중앙 집중화하여 코드 중복을 줄이고, 재사용성을 높일 수 있습니다.
• 유연성 : 객체 생성 방법을 변경하더라도 클라이언트 코드에 영향을 미치지 않으므로 코드의 유연성이 높아집니다.

단점

• 추가적인 클래스 도입 : 팩토리 클래스나 인터페이스가 추가되므로 클래스의 수가 늘어날 수 있습니다.
• 복잡성 증가 : 간단한 객체 생성에는 오히려 코드가 복잡해질 수 있습니다.
• 런타임 비용 : 팩토리 메서드를 호출하여 객체를 생성하는 데 약간의 추가 비용이 발생할 수 있습니다.

반응형

---

사용법

기본

// 데이터베이스 커넥션 인터페이스
public interface IDbConnection
{
    void Connect();
}

// 구체적인 데이터베이스 커넥션 클래스
public class SqlConnection : IDbConnection
{
    public void Connect()
    {

 

단순 팩토리 패턴

단순 팩토리 패턴에서는 객체 생성을 위한 로직을 하나의 팩토리 클래스에 캡슐화합니다.

// 제품 인터페이스
public interface IProduct
{
    void DoSomething();
}

// 구체적인 제품 클래스
public class ConcreteProductA : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("Product A");
    }
}

public class ConcreteProductB : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("Product B");
    }
}

// 팩토리 클래스
public class SimpleFactory
{
    public IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Unknown product type");
        }
    }
}

// 클라이언트 코드
class Program
{
    static void Main()
    {
        SimpleFactory factory = new SimpleFactory();
        IProduct productA = factory.CreateProduct("A");
        productA.DoSomething();

        IProduct productB = factory.CreateProduct("B");
        productB.DoSomething();
    }
}

 

팩토리 메서드 패턴
팩토리 메서드 패턴에서는 객체 생성을 위한 인터페이스를 정의하고, 구체적인 생성 작업을 서브클래스에서 처리합니다.

// 제품 인터페이스
public interface IProduct
{
    void DoSomething();
}

// 구체적인 제품 클래스
public class ConcreteProductA : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("Product A");
    }
}

public class ConcreteProductB : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("Product B");
    }
}

// 창조자 클래스의 추상 정의
public abstract class Creator
{
    public abstract IProduct FactoryMethod();

    public void AnOperation()
    {
        IProduct product = FactoryMethod();
        product.DoSomething();
    }
}

// 구체적인 창조자 클래스
public class ConcreteCreatorA : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ConcreteProductA();
    }
}

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

// 클라이언트 코드
class Program
{
    static void Main()
    {
        Creator creatorA = new ConcreteCreatorA();
        creatorA.AnOperation();

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

 

예제

자동차 공장을 모델링한 팩토리 패턴 예제를 살펴보겠습니다.

// 자동차 인터페이스
public interface ICar
{
    void Drive();
}

// 구체적인 자동차 클래스
public class Sedan : ICar
{
    public void Drive()
    {
        Console.WriteLine("Driving a Sedan");
    }
}

public class Suv : ICar
{
    public void Drive()
    {
        Console.WriteLine("Driving an SUV");
    }
}

// 팩토리 클래스
public class CarFactory
{
    public ICar CreateCar(string type)
    {
        switch (type)
        {
            case "Sedan":
                return new Sedan();
            case "SUV":
                return new Suv();
            default:
                throw new ArgumentException("Unknown car type");
        }
    }
}

// 클라이언트 코드
class Program
{
    static void Main()
    {
        CarFactory factory = new CarFactory();
        ICar sedan = factory.CreateCar("Sedan");
        sedan.Drive();

        ICar suv = factory.CreateCar("SUV");
        suv.Drive();
    }
}

 

팩토리 패턴은 객체 지향 프로그래밍에서 매우 유용한 도구입니다. 이 패턴을 사용하면 객체 생성의 복잡성을 감추고, 클라이언트 코드의 가독성과 유연성을 높일 수 있습니다. 인터페이스를 통해 객체를 생성함으로써 코드의 재사용성을 높이고, 새로운 객체 유형을 추가할 때 기존 코드를 수정하지 않아도 됩니다. 이는 특히 대규모 소프트웨어 개발에서 중요한 장점입니다. 물론 추가적인 클래스 도입으로 인해 초기 설계가 복잡해질 수 있지만, 장기적으로는 유지보수와 확장성 면에서 큰 이점을 제공합니다. 따라서 팩토리 패턴은 잘 설계된 소프트웨어 시스템을 구축하는 데 있어 강력한 도구가 될 수 있습니다.