Question

我的项目中有一组课程（遵循策略模式）。在main函数中，我从服务器接收一个枚举值，并根据它创建一个基类类型的对象。

我正在使用switch / case语句来实现这一目标。我在某处读到，开放/封闭原则不允许在添加新类时打开函数添加新的case语句。

我正在考虑使用Activator.CreateInstance()。它有任何缺点。

还有其他方法可以从枚举类型创建对象吗？

在下面添加示例，即使它不是一个完整的战略模式

abstract public class Mammal
{
   public abstract void MakeSound()
}

class Cat:Mammal
{      
    public override  void MakeSound()
    {
        Console.WriteLine("Meow");        
    }    
}

class Dog:Mammal
{

    public override void MakeSound()
    {
         Console.WriteLine("Bow");        
    }    
}

Main()
{

    MammalTypes mammalType = RecieveValueFromServer();
    Mammal mammalBase
    switch(mammalType) // need to make this dynamic depending upon Enum type
    {
        case MammalTypes.Cat:mammalBase = new Cat()
                             break;
        case MammalTypes.Dog:mammalBase = new Dog()
                             break;            
    }

    mammalBase.MakeSound()
}

Answer 1

实现真正OCP的一种方法可能如下：

定义一个抽象方法Is来强制Mammal的每个具体子类型指定它是否适合枚举的给定值：

abstract public class Mammal
{
    public abstract void MakeSound();

    public abstract bool Is(MammalTypes mammalType);
}

子类中Is的实现如下：

class Cat : Mammal
{
    // other specific members

    public override bool Is(MammalTypes mammalType)
    {
        return mammalType == MammalTypes.Cat;
    }
}

class Dog : Mammal
{
    // other specific members

    public override bool Is(MammalTypes mammalType)
    {
        return mammalType == MammalTypes.Dog;
    }
}

这样做，我们现在可以创建一个MammalFactory类，当给定一个Mammal枚举值扫描可用的类时，当它找到匹配时，它返回该类的一个实例：

public class MammalFactory
{
    private readonly IEnumerable<Type> _mammalTypes;

    public MammalFactory()
    {
        var currentAssembly = Assembly.GetExecutingAssembly();

        _mammalTypes = currentAssembly.GetTypes()
            .Where(t => typeof(Mammal).IsAssignableFrom(t) && !t.IsAbstract);
    }

    public Mammal Create(MammalTypes mammalType)
    {
        return _mammalTypes
            .Select(type => CreateSpecific(type, mammalType))
            .First(mammal => mammal != null);
    }

    public Mammal CreateSpecific(Type type, MammalTypes mammalEnumType)
    {
        var mammalInstance = (Mammal)Activator.CreateInstance(type);

        return mammalInstance.Is(mammalEnumType) ? mammalInstance : null;
    }
}

最终用法如下：

var mammalFactory = new MammalFactory();

var guessWhatMammal = mammalFactory.Create(MammalTypes.Cat);

这完全符合OCP。只需要创建一个新的Mammal类，它就可以自动连接并准备在应用程序中使用。（除了枚举本身之外，无需修改应用程序中的任何其他内容）

这种方法存在一些问题：

它仅扫描正在执行的程序集中的哺乳动物类型
每次需要测试该类型是否合适时，都必须创建一个Mammal实例

虽然可以解决这些问题，但仍有一个问题：复杂性。

这很复杂，因为：

我们将所需代码量增加了一倍
对于刚接触项目的人来说，自动布线可能会让人感到困惑

我认为结论是这样的：设计模式不是严格的规则。为了符合给定的设计，做一些事情是不值得的。相反，我们必须务实，并在模式一致性和有用性/简单性/可读性之间找到完美的平衡。这在很大程度上取决于我们试图解决的问题，在很多情况下，很可能是你在问题中提出的switch陈述。

Answer 2

您可以使用枚举类型中的词典到函数。这些函数创建了您的策略对象：

public delegate Strategy StrategyFactory();
var strategyFactories = new Dictionary<MyEnum, StrategyFactory>();

此字典用于根据枚举值创建对象：

var newStategy = strategyFactories[myEnumValue]();

工厂函数需要以某种方式添加到字典中。为此，您可以公开注册（也可能是注销）方法。

Answer 3

您可以创建一个属性，该属性采用枚举值表示的类型，并将其应用于枚举字段，如下所示：

enum MyEnum {
   [Creates(typeof(FooStrategy))]
   Foo,
   [Creates(typeof(BarStrategy))]
   Bar,
   // etc.
}

[AttributeUsage(AttributeTargets.Field, Inherited=false, AllowMultiple=false)]
sealed class CreatesAttribute : Attribute {
    public Type TypeToCreate { get; private set; }
    public CreatesAttribute(Type typeToCreate) {
        TypeToCreate = typeToCreate;
    }

    public static IDictionary<T, Func<U>> GenerateLookup<T,U>() {
       var query = from field in typeof(T).GetFields()
                   let creates = field.GetCustomAttriubtes(typeof(CreatesAttribute), false) as CreatesAttribute[]
                   let method = CreationMethod(typeof(U)) // create your type here
                   let key = (T)field.GetValue(null)
                   select new { Key = key, Method = method };
       return q.ToDictionary(item => item.Key, item => item.Method);
    }
}

您需要创建班级实例的部分由您自己决定。如果它们都具有相同的构造函数，那么这个方法很简单，因为您可以调用Type.GetConstructor(Type[])然后调用Invoke您的ConstructorInfo实例，或者您可以使用IoC容器并解析实例从类型来看，不要过多担心具有不同参数的构造函数。

然后你可以在你的枚举上为扩展方法创建一个静态类：

public static class MyEnumExtensions {
    static readonly IDictionary<MyEnumType, MyBaseStrategyType> lookup = 
        CreatesAttribute.GenerateLookup<MyEnumType, MyBaseStrategyType>();

    public static MyBaseStrategyType CreateInstance(this MyEnumType key) {
          return lookup[key](/* pass any common constructor values */);
    }
}

最后你会这样称呼它：

var myEnum = MyEnumType.Foo;
var strategy = myEnum.CreateInstance();
// use your strategy

这可以防止您违反开放/封闭原则，并允许您添加任意数量的类，并且只更改Enum，可以使其足够通用以直接从枚举值创建策略实例。 / p>

如何使用枚举解析类类型

3 个答案: