工厂模式但带有对象参数

Question

采用以下经典工厂模式：

public interface IPizza
{
    decimal Price { get; }
}

public class HamAndMushroomPizza : IPizza
{
    decimal IPizza.Price
    {
        get
        {
            return 8.5m;
        }
    }
}
public abstract class PizzaFactory
{
    public abstract IPizza CreatePizza(ItalianPizzaFactory.PizzaType pizzaType);
}

public class ItalianPizzaFactory : PizzaFactory
{
    public enum PizzaType
    {
        HamMushroom,
        Deluxe,
        Hawaiian
    }

    public override IPizza CreatePizza(PizzaType pizzaType)
    {
        switch (pizzaType)
        {
            case PizzaType.HamMushroom:
                return new HamAndMushroomPizza();
            case PizzaType.Hawaiian:
                return new HawaiianPizza();
            default:
                throw new ArgumentException("The pizza type " + pizzaType + " is not recognized.");
        }
    }
}

如果一个（或多个）具体披萨需要特定于构造时具体实现的参数，该怎么办？例如，假设 HamAndMushroom 工厂需要一个名为 MushroomType 的参数，并且需要此参数来实例化该对象吗？

Answer 1

您可以将参数添加到工厂的创建者方法中。但是，如果参数数量越来越多（对我来说会超过 2-3 个），特别是如果这些参数中的部分或全部是可选的，并且具有合理的默认值，您可以考虑将工厂变成 Builder。

这可能特别适合披萨，通常有相同的外壳，只是有不同的配料（组合）。 Builder 非常接近常见的订购方式，例如“带有萨拉米香肠、西红柿、玉米和双层奶酪的披萨”。 OTOH 对于“预定义”披萨，您可能需要定义辅助工厂方法，例如 createMargaritaPizza 或 createHawaiiPizza，然后在内部使用构建器创建具有特定于该类型的配料的披萨披萨。

Answer 2

您必须为该工厂类添加另一个 CreatePizza() 方法。这意味着工厂的用户将无法创建这些类型的披萨，除非他们专门使用 HamAndMushroomPizzaFactory 类的实例。如果他们只有 PizzaFactory 引用，则只能调用无参数版本，并且无法创建一般的火腿和蘑菇披萨。

Answer 3

您可以传递一个新参数，例如 Map。并查询每个具体构造函数的属性。那么所有的方法都会有相同的签名。
然而，通过这个解决方案，构造函数的调用者必须知道具体构造函数的具体属性......（耦合）

Answer 4

您可以尝试这样的操作：

interface IPizza
{
}

class Pizza1 : IPizza
{
  public Pizza1(Pizza1Parameter p)
  {
  }
}

class Pizza2 : IPizza
{
  public Pizza2(Pizza2Parameter p)
  {
  }
}

interface IPizzaParameter
{
  object Type { get; set; }
}

class Pizza1Parameter : IPizzaParameter
{
  public object Type { get; set; }
}

class Pizza2Parameter : IPizzaParameter
{
  public object Type { get; set; }
}

static class PizzaFactory
{
  public enum PizzaType
  {
    Pizza1,
    Pizza2,
  }

  public static IPizza CreatePizza(PizzaType type, IPizzaParameter param)
  {
    switch (type)
    {
      case PizzaType.Pizza1:
        return new Pizza1(param as Pizza1Parameter);
      case PizzaType.Pizza2:
        return new Pizza2(param as Pizza2Parameter);
    }

    throw new ArgumentException();
  }
}

class Program
{
  static void Main()
  {
    var param1 = new Pizza1Parameter();
    var p1 = PizzaFactory.CreatePizza(PizzaFactory.PizzaType.Pizza1, param1);
  }
}

恕我直言，具有特定于实现的参数的工厂概念看起来是错误的。

Answer 5

当参数数量变得非常高时，我确实认为工厂变得不那么方便和多余，因为它的主要目的是使创建过程变得不可见。

另外，当参数是“必需的”时，我也认为 Builder 失去了它的魅力。

在这种情况下，我可能希望将工厂与“参数对象”结合起来，这将减少需要传递到静态工厂方法中的参数数量，并且可以使创建逻辑比使用生成器更具可读性和简洁性。当然，还需要创建该参数对象，但至少它会在您的应用程序中以一种单一形式存在。

Answer 6

首先，我觉得奇怪的是，抽象类 PizzaFactory 包含一个抽象通用方法 CreatePizza，它采用更具体类型的参数ItalianPizzaFactory.PizzaType。

为了解决我刚才提到的问题和帖子中提到的问题，我建议采用以下方法。

public struct PizzaDefinition
{
    public readonly string Tag; 
    public readonly string Name;
    public readonly string Description;
    public PizzaDefinition(string tag, string name, string description)
    {
        Tag = tag; Name = name; Description = description;
    }
}

public abstract class PizzaFactory
{
    public abstract IEnumerable<PizzaDefinition> GetMenu();
    public abstract IPizza CreatePizza(PizzaDefinition pizzaDefinition);
}


public class ItalianPizzaFactory : PizzaFactory
{
    public enum PizzaType
    {
        HamMushroom,
        Deluxe,
        Hawaiian
    }    

    public override IEnumerable<PizzaDefinition> GetMenu()
    {
        return new PizzaDefinition[] {
            new PizzaDefinition("hm:mushroom1,cheese3", "Ham&Mushroom 1", "blabla"),
            new PizzaDefinition("hm:mushroom2,cheese1", "Ham&Mushroom 2", "blabla"),
            new PizzaDefinition("dx", "Deluxe", "blabla"),
            new PizzaDefinition("Hawaian:shrimps,caramel", "Hawaian", "blabla")
        };
    }

    private PizzaType ParseTag(string tag, out object[] options){...}

    public override IPizza CreatePizza(PizzaDefinition pizzaDefinition)
    {
        object[] options;
        switch (ParseTag(pizzaDefinition.Tag, out options))
        {
            case PizzaType.HamMushroom:
                return new HamAndMushroomPizza(options);
            case PizzaType.Hawaiian:
                return new HawaiianPizza();
            default:
                throw new ArgumentException("The pizza" + pizzaDefinition.Name + " is not on the menu.");
        }
    }
}

如您所见，ParseTag() 方法可以具有任意复杂性，解析纯文本或加密值。或者，Tag 字段可以是一个简单的 int，它在内部映射到某个披萨食谱表，即使披萨内容略有变化，也可以使用完全不同的食谱。

Answer 7

您可以使用反射：

using System.Reflection;

// ...

public override IPizza CreatePizza(PizzaType pizzaType, params object[] parameters) {
            return (IPizza)
                   Activator.CreateInstance(
                        Assembly
                             .GetExecutingAssembly()
                             .GetType(pizzaType.ToString()),
                        parameters);
        }