0

在像下面这样需要基于某些条件逻辑来实例化对象的场景中，工厂方法模式是否可以帮助避免客户端代码由于 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();


    }
}
4

2 回答 2

5

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


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();
    }
}
于 2010-07-22T23:44:57.943 回答
2

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

工厂模式要求 Concrete Creator 从 Creator 派生。通常，Creator 将产品的创建委托给 Concrete Creator。当将来可能添加新工厂时，这很有用。例如，假设您创建了一个新工厂，可以用更少的资源制造特定产品（计数用作“资源”的代理）。 

    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();
      }
    }
于 2010-10-22T20:56:18.700 回答