使用带有接受不同数量参数的派生类的工厂模式

Question

我正在使用以下factory pattern:

using System;

class Program
{
    abstract class Position
    {
    public abstract string Title { get; }
    }

    class Manager : Position
    {
    public override string Title
    {
        get
        {
        return "Manager";
        }
    }
    }

    class Clerk : Position
    {
    public override string Title
    {
        get
        {
        return "Clerk";
        }
    }
    }

    class Programmer : Position
    {
    public override string Title
    {
        get
        {
        return "Programmer";
        }
    }
    }

    static class Factory
    {
    /// <summary>
    /// Decides which class to instantiate.
    /// </summary>
    public static Position Get(int id)
    {
        switch (id)
        {
        case 0:
            return new Manager();
        case 1:
        case 2:
            return new Clerk();
        case 3:
        default:
            return new Programmer();
        }
    }

使用这种模式的方法在同一来源的示例中：

static void Main()
{
for (int i = 0; i <= 3; i++)
{
    var position = Factory.Get(i);
    Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title);
}
}

如果我的派生类为其构造函数使用不同数量的参数，我应该使用这种模式吗？

我可能需要进行的修改是在实例化工厂时：

var position = Factory.Get(i);

我可能需要为所有派生类传入参数，无论它们是否会使用它们：

var position = Factory.Get(i, param1, param2, param3);

需要修改switch语句：

public static Position Get(int id, param1, param2, param3) //HERE IS THE MODIFIED PARAM LIST
{
    switch (id)
    {
    case 0:
        return new Manager(param1); //MODIFIED
    case 1:
    case 2:
        return new Clerk(param2, param3); //MODIFIED
    case 3:
    default:
        return new Programmer(param3); //MODIFIED
    }
}

我对工厂模式所做的修改是否会破坏该模式，我是否应该使用不同的模式来创建对象？

Answer 1

使用工厂是为了抽象出如何创建对象的要求，让客户端不需要知道具体如何创建对象。

该模式最经典的用途之一是让应用根据可能返回 MSSQL、SQLite、MySQL 等连接的键创建数据库连接。客户端并不关心实现是什么，只要它支持所有必需的操作即可。

所以客户端应该完全不知道所需的参数。

这里是怎么做的。

我稍微扩展了Position 类：

abstract class Position
{
    public abstract string Title { get; }
}

class Manager : Position
{
    public Manager(string department) { }
    public override string Title => "Manager";
}

class Clerk : Position
{
    public override string Title => "Clerk";
}

class Programmer : Position
{
    public Programmer(string language) { }
    public override string Title => "Programmer";
}

现在我创建了这样的Factory 类：

static class Factory
{
    private static Dictionary<int, Func<Position>> _registry =
        new Dictionary<int, Func<Position>>();

    public static void Register(int id, Func<Position> factory)
    {
        _registry[id] = factory;
    }

    public static Position Get(int id)
    {
        return _registry[id].Invoke();
    }
}

然后使用工厂变得很容易。当你初始化应用程序时，你会编写这样的代码：

Factory.Register(1, () => new Manager("Sales"));
Factory.Register(2, () => new Clerk());
Factory.Register(3, () => new Programmer("C#"));

现在，稍后，当客户端代码需要 Position 对象时，它只需要这样做：

var position = Factory.Get(3);

在我的测试中，当我输出position.Title 时，我将Programmer 打印到控制台。

Answer 2

这个例子有点太愚蠢了，但是是的，你可以。

也就是说，这个例子可能会导致一些问题，因为程序员可能会对如何使用工厂感到困惑。例如，假设您必须定义一个 GUI 来创建位置：GUI 是否会要求用户提供所有 3 个param 值，即使它们对首先定义的位置没有意义？如果您回答“是”，用户会感到困惑，如果您回答“否”，那么工厂就不是应有的黑匣子了。

我使用这种方法的一个例子是计费；我的应用程序将同一个月的服务批量计费给很多人。有的人按月的自然天数计费，有的人按可工作的天数计​​费。由于获得可工作的日子有点慢（它必须咨询数据库以了解当地和国定假日）我将其缓存并将其传递给需要它的实例。

类似于（Java）：

public class BillerFactory {
  private HashMap<Date, ListOfHolidaysInMonth> holidayCache =
     new HashMap<>();

  ...

  public getBiller(BillingType billingType, Date firstOfMonth) {
    switch (billingType) {
      case BillingType.NATURAL:
         return new NaturalBiller(firstOfMonth);
      case BillingType.LABORAL:
         ListOfHoliday holidays = this.holidayCache.get(firstOfMonth);
         if (holidays == null) {
            holidays = this.calculateHolidays(firstOfMonth);
            holidayCache.put(firstOfMonth, holidays);
         }
         return new LaboralBiller(firstOfMonth, holidays);
       }
     }

TLDR：问题不在于构造函数具有不同的参数，而是在您的示例中，您强制客户端提供可能没有意义的数据。

Answer 3

下面的代码将使用 Position 类中的默认构造函数。

         static void Main(string[] args)
        {
            Manager mngr = new Manager();
        }
    }
    public abstract class Position
    {
        public abstract string Title { get; }
        public Position()
        {
        }
    }
    public class Manager : Position
    {
        public override string Title
        {
            get
            {
                return "Manager";
            }
        }
    }

Answer 4

我没有足够的上下文来建议一个好的替代方案，但是您的示例使用起来不舒服：工厂模式的想法是封装对象的创建，但是由于您对不同的对象有一组不同的参数，所以您有要了解具体实现之间的一些差异，或者您每次都必须提供无用的数据。也许只使用构造函数会更好？