具有可以具有不同类子类型的类的工厂模式

Question

我有来自多个组织（警察、消防、办公室）的数据，需要以不同格式输出。

为了实现这一点，我定义了以下内容（这有点简化）：

事务类 -

1. “成功”指示符 - 布尔值。
2. “部门类型”- 字符串或枚举。
3. 可以是任何类型的类 - 警察、消防或办公室（您将看到我的问题是关于此的）。
4. GenerateOutput() 方法 - 处理文件格式的生成。

警察课

1. 年龄 - 字符串
2. VehicleNumber - 整数
3. 主管 - 字符串

消防类

1. 名称 - 字符串
2. FireEngineNumber - 整数
3. 县 - 枚举
4. WorkTimings - 枚举

办公类

1. 年龄 - 字符串
2. DeskNumber - 整数
3. 部门 - 字符串
4. PayScale - 枚举
5. IsManagement - 布尔

如您所见，Police、Fire 和 Office 类没有任何共同点，主要用作数据承载实体。我打算使用工厂返回带有数据的适当通用（不是 C# 通用）事务对象（其中包含 Police、Fire 或 Office 数据的事务对象），然后将返回的对象传递给确定每个人需要的文件格式（CSV、Excel 或 XML；在配置文件中指定）的策略模式。

我的问题在于 Transaction 对象的定义。

1. “3”中的类是什么类型。 Transaction类的需要是什么？每个组织的数据不同，没有共同的成员，我无法为所有人定义一个共同的类。

2. 整体设计是否合适？我还应该考虑哪些其他设计？

基于以下 Peter 的 cmets： 我认为使用泛型可能会起作用，但我遇到了一个问题。我想使用工厂返回请求的对象，使用 GetTransactionObject，如下所示。 GetTransactionObject 的返回类型应该是什么来适应这个。

类事务工厂 {

        Dictionary<string, Type> typeClassLookup;

    public TransactionFactory()
    {
        typeClassLookup = new Dictionary<string, Type>();
        typeClassLookup.Add("Police", typeof(PoliceData));
        typeClassLookup.Add("Fire", typeof(FireData));
    }

    Transaction<????> GetTransactionObject(string org)
    {

        if( typeClassLookup.TryGetValue(org, out typeValue))
        {
            switch (typeValue.ToString())
            {
                case "policeData":
                    transactionObject = new Transaction<PoliceData>() { Data = new PoliceData(), params = null};
                case "FireData":
                    transactionObject = new Transaction<FireData>() {Data = new FireData(), params = null};
            }
        }
        return transactionObject;

Answer 1

如果类型真的没有共同点，那么你不需要显式的基类。 System.Object 就足够了，就像许多其他泛型类型一样（即任何没有约束的泛型类型）。

换句话说，你可以声明为：

class Transaction<T>
{
    public bool Success { get; private set; }
    public T Entity { get; private set; }

    public Transaction(bool success, T entity)
    {
        Success = success;
        Entity = entity;
    }

    public void GenerateOutput() { /* something goes here */ }
}

就个人而言，我会避免添加“部门类型”成员。毕竟，这是类型参数T 隐含的。但如果你愿意，你可以很容易地把它添加到上面。

如果并且当您发现这些类型确实有一些共同点时，您的 Transaction<T> 类型需要做的不仅仅是简单地保留其中一种类型的实例（这几乎是它在没有约束的情况下所能做的所有事情)，然后您将能够将该通用性放入接口或基类（取决于具体需要），并在 Transaction<T> 类的约束中指定。

请注意，尚不清楚您对GenerateOutput() 的作用是什么，或者它应该如何工作。但是假设您想要特定于每个 Entity 值的输出，在我看来 that 是您的“共同点”。即，需要实现该方法的根本不是Transaction<T> 类，而是每个实体类型。在这种情况下，你有这样的事情：

interface IDepartmentEntity
{
    void GenerateOutput();
}

class Office : IDepartmentEntity
{
    public void GenerateOutput() { /* department-specific logic here */ }
}

// etc.

然后你可以声明：

class Transaction<T> where T : IDepartmentEntity
{
    public bool Success { get; private set; }
    public T Entity { get; private set; }

    public Transaction(bool success, T entity)
    {
        Success = success;
        Entity = entity;
    }

    public void GenerateOutput() { Entity.GenerateOutput(); }
}

编辑：

Per Prasant 的后续编辑，在GetTransactionObject() 上征求意见...

执行此操作的正确方法取决于调用者和上下文，问题中未提供详细信息。恕我直言，最佳场景是调用者知道类型的地方。这允许使用泛型的全部功能。

例如：

class TransactionFactory
{
    public Transaction<T> GetTransactionObject<T>()
        where T : IDepartmentEntity, new()
    {
        return new Transaction<T>()
        {
            Data = new T(),
            params = null
        }
    }
}

然后你这样调用：

Transaction<FireData> transaction = factory.GetTransactionObject<FireData>();

调用者当然已经知道它正在创建的类型，然后可以填写transaction.Data对象的适当属性。

如果这种方法不可行，那么您将需要Transaction<T> 本身拥有一个基类，或实现一个接口。请注意，在我原来的示例中，IDepartmentEntity 接口只有一个方法，与Transaction 类中的GenerateOutput() 方法相同。

所以也许，该接口实际上是关于生成输出而不是作为数据实体。调用它，而不是 IDepartmentEntity，类似于 IOutputGenerator。

在这种情况下，您可能会遇到这样的情况：

class Transaction<T> : IOutputGenerator
{
    // all as before
}

class TransactionFactory
{
    public IOutputGenerator GetTransactionObject(string org)
    {
        if( typeClassLookup.TryGetValue(org, out typeValue))
        {
            switch (typeValue.ToString())
            {
                case "policeData":
                    transactionObject = new Transaction<PoliceData>() { Data = new PoliceData(), params = null};
                case "FireData":
                    transactionObject = new Transaction<FireData>() {Data = new FireData(), params = null};
            }
        }
        return transactionObject;
    }
}

这是一个较差的解决方案，因为这意味着调用者只能直接访问IOutputGenerator 功能。其他任何事情都需要进行一些类型检查和特殊情况的代码，这确实应该尽可能避免。

注意：如果Transaction 类型有其他成员，比如GenerateOutput() 方法，独立于此处包含的类型T，这对不知道T 的调用者很有用，那么上面的一个可能的变化是不重用用于部门特定数据类型的接口，而是为Transaction<T>声明一个基类，当然命名为Transaction，包含所有与T无关的成员.那么返回值可以是Transaction。

Answer 2

1. “3”中的类是什么类型。 Transaction 类的需要是什么？

要将您的部门类与各种导出类型分离，我建议您让部门类实现一个通用接口。像这样的：

public interface Exportable {
    // return a list of attribute names, values, and types to export
    IList<Tuple<String, String, Type>> GetAttributes();
}

例如：

public class Police : Exportable {
    public IList<Tuple<String, String, Type>> GetAttributes() {
        // return list size 3 - attribute info for Age, VehicleNumber, Supervisor
    }
}

1. 整体设计合适吗？我还应该考虑哪些其他设计？

Transaction 类的设计似乎不太适合这个问题。

考虑一个Export 类，每个导出类型都有一个方法，每个方法接收从Exportable 接口方法返回的属性。基本大纲：

public static class Export {
    public static boolean CSV(IList<Tuple<String, String, Type>> attributes) {
        // export attributes to CSV, return whether succeeded
    }

    public static boolean Excel(IList<Tuple<String, String, Type>> attributes) {
        // export attributes to Excel, return whether succeeded
    }

    // same thing for XML
}