具有类型参数的通用工厂

Question

我有以下情况。

我的 Factory 类需要根据 CreateStrategy 函数的输入字符串参数创建适当的 Strategy 对象。

Strategy1、Strategy2 等都派生自一个通用的 StrategyBase 类。然而，每种策略都有不同的验证机制，它是工厂类的类型参数。但是，StrategyValidators 不是任何通用类型，并且具有不同的接口。

因此，在下面的代码中，我无法对 StrategyValidator 类型指定任何通用约束。

我是 C# 新手，因此不确定是否存在任何机制来克服这个设计问题。请推荐

public class Factory
{
    //Create the appropriate Concrete Implementation class based on the type
    public static StrategyBase CreateStrategy<StrategyValidator>(String Type)
    {
        StrategyBase EnumImp = null;

        // WMI based implementation
        if (Type == "Type1")
        {
            s = Strategy1<StrategyValidator>.Instance;
        }
        else if (Type = "Type2")
        {
            s = Strategy2<StrategyValidator>.Instance;
        }
        return s;
    }

    private StrategyBase s;
}

这是预期的用途

Factory f = new Factory(); 

f.CreateStrategy<WMIValidator>("WMI");
f.CreateStrategy<ABCDValidator>("ABCD");

其中WMIValidator 和ABCDValidator 是不相关的类型，但CreateStrategy 函数创建的实际类在层次结构中是相关的，例如有一个共同的基础StrategyBase

这里有一个示例代码来说明问题

namespace TestCSharp
{
    public interface IStrategy
    {
    };

    public interface S1 : IStrategy
    {
        void f1();
        void f2();
    };

    public class S1Concrete : S1
    {
        public void f1() { }
        public void f2() { }
    }

    public interface S2 : IStrategy
    {
        void f3();
        void f4();
    };

    public class S2Concrete : S2
    {
        public void f3() { }
        public void f4() { }
    };

    public interface ProductBase
    {
    };

    class Product1<T> : ProductBase where T : S1
    {
    };

    class Product2<T> : ProductBase where T : S2
    {
    };

    public class Factory
    {
        public ProductBase Create<T>(String Type)
        {
            if (Type == "P1")
                return new Product1<T>();
            else if (Type == "P2")
                return new Product2<T>();
        }
    };

    class Program
    {
        static void Main(string[] args)
        {
            Factory f = new Factory();
            ProductBase s = f.Create<S1Concrete>("Type1");
        }
    }
}

我得到的错误是

类型“T”不能用作泛型类型中的类型参数“T” 或方法“TestCSharp.Product1”。没有拳击转换或 类型参数从 'T' 到 'TestCSharp.S1' 的转换。

Answer 1

我并不完全了解您的场景，但据我所知，您正在使用的工厂模式必须使用反射来实例化产品。这有点难看，因为它没有给消费者任何关于给定产品名称可以使用哪些策略类型的提示。

public class Factory
{
    public ProductBase Create<T>(string name)
    {
        Type type;
        switch (name)
        {
            case "P1":
                type = typeof (Product1<>);
                break;
            case "P2":
                type = typeof (Product2<>);
                break;
            case "P3":
                type = typeof (Product3<>);
                break;
            default:
                return null;
        }
        type = type.MakeGenericType(typeof (T));
        return (ProductBase) Activator.CreateInstance(type);
    }
}

Answer 2

我认为在这种情况下的答案是，它取决于您希望Product 和Strategy 做什么。你似乎想要做的是将你的逻辑分成两个分支。然后你想通过使用泛型再次耦合它，但正如你所注意到的，它不起作用。

考虑一个场景，类似于你上面的场景——但是每个实现IStrategy 的类都有一个而不是两个产生副作用的方法（即打印一个字符串）。当允许的类型范围有共同点时，您可以使用泛型。在我刚才提到的情况下，两者都有一个返回 void 并且不接受任何参数的方法；所以我们可以给IStrategy添加一个方法，例如：

public interface IStrategy
{
    void ExecuteLogic();
};

public class S1 : IStrategy
{
    public void ExecuteLogic()
    {
        OneMethod();
    }

    void OneMethod()
    {
        Console.WriteLine("Hello");
    }
};

public class S2 : IStrategy
{
    public void ExecuteLogic()
    {
        TotallyDifferentMethod();
    }

    void TotallyDifferentMethod()
    {
        Console.WriteLine("World");
    }
};

现在，您还说Strategy1 和Strategy2 具有不同的验证机制。但是，在我看来，您在相同的方法和上下文中使用它们（因此也使用相同的参数和变量），所以一定有一些东西使它们相似。尽管如此，以我们需要的方式定义了IStrategy，我们可以将其用作Create<T> 的约束。所以，Factory 变成：

public class Factory
{
    public ProductBase Create<T>(String Type) where T : IStrategy
    {
        if (Type == "P1")
            return new Product1<T>();
        else if (Type == "P2")
            return new Product2<T>();
        return null;
    }
};

但还有一种情况。如果您不希望 Product1 以 S2 作为泛型类型被调用，或者 Product2 以 S1 作为其泛型类型，那么为什么首先使用泛型呢？您可以轻松地将产品与其相关策略相结合，并显着简化代码。

如果我错过了什么（或整个问题），请发表评论，我会尝试调整我的答案。

编辑：因为现在你已经重新定义了你的例子并使用了S1 和S2 作为接口，我明白你的意思了。一种方法是为Factory.Create 定义多个泛型类型和约束。示例：

public ProductBase Create<T1, T2>(String Type) where T1 : S1 where T2 : S2

正如你所说的那样，否则这是不可能的，因为S1 和S2 没有共同的祖先可以被你的Product 类接受。

Answer 3

您可以更改函数以将 StrategyValidator 作为类型。

来自

public static StrategyBase CreateStrategy<StrategyValidator>(String Type)

到

public static StrategyBase CreateStrategy<T>(String Type) where T:StrategyValidator

要回答您的问题，您无法避免条件检查。

为了简化代码，可以将不同的组合（“Type1”、“Type2”等）移动到dictionary 或者如果您使用Dependency Injection，则可以移动到配置中，然后您可以进行反思。

示例。

    if (!dict.ContainsKey(key)) 
       throw New InvalidArgumentException();

    StrategyBase EnumImp = null;

    var instance = dict[key].MakeGenericType(typeOf(type)).GetProperty("Instance",  BindingFlags.Static | BindingFlags.Public ));   //dict is Dictionary<string, Type>

Answer 4

您是否考虑过重载 Create 函数？我现在没有方便的 VisualStudio，但以下代码是否适合您的情况？

namespace ... {
    // ... other code here...

    public class Factory {
        public Product1<T> Create<T>() where T : S1 {
            return new Product1<T>();
        }
        public Product2<T> Create<T>() where T : S2 {
            return new Product2<T>();
        }
    }

    class Program {
        static void Main(string[] args) {
            Factory f = new Factory();
            ProductBase s = f.Create<S1Concrete>();
        }
    }
}

此外，您可能希望将类型约束移至较低级别。考虑编写一个抽象的 ProductBase 基类（继承自 IProductBase 接口？），如下所示：

class ProductBase<T> : IProductBase where T : IStrategy { }

这可能有助于缓解您的一些头痛。