工厂方法模式以避免基于条件逻辑的对象实例化

Question

在如下场景中，需要根据某些条件逻辑来实例化对象，工厂方法模式是否可以帮助避免客户端代码由于 if/elseif 条件的数量而变得混乱（这也可能是如果由于逻辑的不同变化而需要创建越来越多的产品，这将是维护的噩梦）。

或者还有其他设计模式可以拯救吗？

public interface IProduct
{
    void Method1();
}

public class ProductA : IProduct
{
    void Method1()
    {
    }
}

public class ProductB : IProduct
{
    void Method1()
    {
    }
}

public class ProductC : IProduct
{
    void Method1()
    {
    }
}

public class Client
{
    public void Test()
    {
        int count = 5;

        IProduct product;

        if (count < 10)
        {
            product = new ProductA();
        }
        else if (count == 10)
        {
            product = new ProductB();
        }
        else if (count > 10)
        {
            product = new ProductC();
        }

        product.Method1();


    }
}

Answer 1

看起来工厂模式正是您想要的：

public class ProductFactory
{
    public IProduct GetProduct(int count)
    {
        if (count < 10)
        {
            return new ProductA();
        }
        else if (count == 10)
        {
            return new ProductB();
        }
        else if (count > 10)
        {
            return new ProductC();
        }
    }
}

然后无论您的客户端代码需要一个实例，它都可以去

public class Client
{
    public void Test()
    {
        ProductFactory factory = new ProductFactory();

        IProduct product = factory.GetProduct(5);

        product.Method1();
    }
}

Answer 2

我不相信Carver先生的解决方案严格遵循GOF设计模式书中描述的工厂模式的结构。然而，它是一种非常常见的编程习惯（简单工厂），并且可能是这种设计的好方法。

工厂模式要求从创建者派生具体创建者。通常，创建者将产品的创建委托给具体创建者。当将来可能添加新工厂时，这非常有用。例如，想象一下，如果您创建了一个新工厂，可以使用较少的资源（计数用作“资源”的代理）来制造特定产品。

    public interface IProduct
    {
      void PerformService();
    }

    public class ProductA : IProduct
    {
      public void PerformService()
      {
        Console.WriteLine("Product A's service.");
      }
    }

    public class ProductB : IProduct
    {
      public void PerformService()
      {
        Console.WriteLine("Product B's service.");
      }
    }

    public class ProductC : IProduct
    {
      public void PerformService()
      {
        Console.WriteLine("Product C's service.");
      }
    }

    abstract class ProductFactory
    {
      public abstract IProduct CreateProduct(int count);
    }

    class OriginalFactory : ProductFactory
    {
      public override IProduct CreateProduct(int count)
      {
        if (count < 10)
        {
          return new ProductA();
        }
        else if (count == 10)
        {
          return new ProductB();
        }
        else if (count > 10)
        {
          return new ProductC();
        }
        else
        {
          return null;
        }
      }
    }

    class NewFactory : ProductFactory
    {
      public override IProduct CreateProduct(int count)
      {
        if (count < 20)
        {
          return new ProductA();
        }
        else if (count == 20)
        {
          return new ProductB();
        }
        else if (count > 20)
        {
          return new ProductC();
        }
        else
        {
          return null;
        }
      }
    }

    public class FactoryTest
    {
      public void TestNew()
      {
        ProductFactory factory = new NewFactory();
        IProduct product = factory.CreateProduct(10); // Product B
        product.PerformService();
      }
      public void TestOld()
      {
        ProductFactory factory = new OriginalFactory();
        IProduct product = factory.CreateProduct(10); // Product A
        product.PerformService();
      }
    }