如何在C＃中使用自定义属性替换开关中的开关？

Question

我有一个工厂方法，根据三个枚举值返回正确的子类。要做的一种方法是，在交换机中使用交换机。很明显，我不太喜欢这个选项。

我认为另一种选择是在C＃中使用属性。每个子类都有一个具有3个枚举值的属性，并且在工厂中，我只需要获得与工厂中的枚举值相对应的枚举值相同的类。

但是，我对属性还是比较陌生的，在网络中我没有找到任何合适的解决方案。如果有人，可以给我一些提示或代码行，我真的很感激！

Answer 1

首先，声明你的属性，并把它添加到您的类。

enum MyEnum 
{ 
    Undefined, 
    Set, 
    Reset 
} 

class MyEnumAttribute : Attribute 
{ 
    public MyEnumAttribute(MyEnum value) 
    { 
     Value = value; 
    } 

    public MyEnum Value { get; private set; } 
} 

[MyEnum(MyEnum.Reset)] 
class ResetClass 
{ 
} 

[MyEnum(MyEnum.Set)] 
class SetClass 
{ 
} 

[MyEnum(MyEnum.Undefined)] 
class UndefinedClass 
{ 
} 

然后，您可以使用此代码创建一个包含您的枚举和类型的字典，并动态创建一个类型。

//Populate a dictionary with Reflection 
var dictionary = Assembly.GetExecutingAssembly().GetTypes(). 
    Select(t => new {t, Attribute = t.GetCustomAttribute(typeof (MyEnumAttribute))}). 
    Where(e => e.Attribute != null). 
    ToDictionary(e => (e.Attribute as MyEnumAttribute).Value, e => e.t); 
//Assume that you dynamically want an instance of ResetClass 
var wanted = MyEnum.Reset; 
var instance = Activator.CreateInstance(dictionary[wanted]); 
//The biggest downside is that instance will be of type object. 
//My solution in this case was making each of those classes implement 
//an interface or derive from a base class, so that their signatures 
//would remain the same, but their behaviors would differ. 

正如你可能会注意到，呼吁Activator.CreateInstance不是高性能。因此，如果您想稍微提高性能，可以将字典更改为Dictionary<MyEnum,Func<object>>，而不是将类型添加为值，而是添加包装每个类的构造函数的函数，并将它们作为对象返回。

编辑：我加入一个ConstructorFactory类，改编自this页。

static class ConstructorFactory 
{ 
    static ObjectActivator<T> GetActivator<T>(ConstructorInfo ctor) 
    { 
     var paramsInfo = ctor.GetParameters(); 
     var param = Expression.Parameter(typeof(object[]), "args"); 
     var argsExp = new Expression[paramsInfo.Length]; 
     for (var i = 0; i < paramsInfo.Length; i++) 
     { 
      Expression index = Expression.Constant(i); 
      var paramType = paramsInfo[i].ParameterType; 
      Expression paramAccessorExp = Expression.ArrayIndex(param, index); 
      Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType); 
      argsExp[i] = paramCastExp; 
     } 
     var newExp = Expression.New(ctor, argsExp); 
     var lambda = Expression.Lambda(typeof(ObjectActivator<T>), newExp, param); 
     var compiled = (ObjectActivator<T>)lambda.Compile(); 
     return compiled; 
    } 

    public static Func<T> Create<T>(Type destType) 
    { 
     var ctor = destType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).First(); 
     Func<ConstructorInfo, object> activatorMethod = GetActivator<Type>; 
     var method = typeof(ConstructorFactory).GetMethod(activatorMethod.Method.Name, BindingFlags.Static | BindingFlags.NonPublic); 
     var generic = method.MakeGenericMethod(destType); 
     dynamic activator = generic.Invoke(null, new object[] { ctor }); 
     return() => activator(); 
    } 

    delegate T ObjectActivator<out T>(params object[] args); 
} 

你可以用它来替代Activator.CreateInstance，它提供了如果结果被缓存更高的性能。

var dictionary = Assembly.GetExecutingAssembly().GetTypes(). 
    Select(t => new { t, Attribute = t.GetCustomAttribute(typeof(MyEnumAttribute)) }). 
    Where(e => e.Attribute != null). 
    ToDictionary(e => (e.Attribute as MyEnumAttribute).Value, 
       e => ConstructorFactory.Create<object>(e.t)); 
var wanted = MyEnum.Reset; 
var instance = dictionary[wanted](); 

Answer 2

看看这篇文章：Creating Custom Attributes。然后，您可以使用反射（例如GetCustomAttributes）来获取属性及其值。

希望这有助于

Answer 3

[AttributeUsage(AttributeTargets.Class)] 
    public class SampleClass : Attribute { 
     public SampleClass() : base() { } 
     public SampleClass(YourEnum attributeValue) : this() { MyAttributeProperty = attributeValue; } 
     public YourEnum MyAttributeProperty { get; set; } 
    } 

    public enum YourEnum { Value1, Value2, Value3 } 

    [SampleClass(YourEnum.Value1)] 
    public class ExampleValue1Class { } 

    public class LoadOnlyClassesWithEnumValue1 { 
     public LoadOnlyClassesWithEnumValue1() { 

      Type[] allTypes = Assembly.GetExecutingAssembly().GetExportedTypes(); 
      foreach (var type in allTypes) { 
       if (type.GetCustomAttributes(typeof(SampleClass), false).Length > 0) { 
        SampleClass theAttribute = type.GetCustomAttributes(typeof(SampleClass), false).Single() as SampleClass; 
        // this type is using SampleClass - I use .Single() cause I don't expect multiple SampleClass attributes, change ths if you want 
        // specify true instead of false to get base class attributes as well - i.e. ExampleValue1Class inherits from something else which has a SampleClass attribute 
        switch (theAttribute.MyAttributeProperty) { 
         case YourEnum.Value1: 
          // Do whatever 
          break; 
         case YourEnum.Value2: 
          // you want 
          break; 
         case YourEnum.Value3: 
         default: 
          // in your switch here 
          // You'll find the ExampleValue1Class object should hit the Value1 switch 
          break; 
        } 
       } 
      } 
     } 
    } 

这样，你可以指定你的枚举作为参数的属性。实质上，这是一个非常简单和轻量级的DI容器。 我建议任何更复杂的东西，像使用StructureMap或NInject。

Answer 4

可以使用属性来保存信息，但最终决策过程仍然必须进行，并且可能不会有太大的不同;只是增加了属性的复杂性。无论您从何处获得信息以作出决定，决策的性质都保持不变，从现有的三个列举或属性中。

寻找一种方法来结合三个枚举可能会更有成效。

枚举可以是任何整数类型，因此消除嵌套（和冗余）开关的最简单方法是将枚举组合在一起。如果枚举是标志值的集合，这是最简单的。也就是说，枚举的每个值都具有二进制字符串中单个位的值（第一位为1，第二位为2，第三位为8，16等）。

假设每个枚举的值可以连接在一起，它将选择过程减少为单个switch语句。这可以通过连接，相乘或者增加枚举值来完成 - 但是它们如何连接在一起取决于枚举，并且在不知道更多细节的情况下很难提供更明确的方向。

Answer 5

另一种解决方案是使用依赖注入（DI）容器。例如使用Unity DI您可以：使用

// Register a named type mapping 
myContainer.RegisterType<IMyObject, MyRealObject1>(MyEnum.Value1.ToString()); 
myContainer.RegisterType<IMyObject, MyRealObject2>(MyEnum.Value2.ToString()); 
myContainer.RegisterType<IMyObject, MyRealObject3>(MyEnum.Value3.ToString()); 
// Following code will return a new instance of MyRealObject1 
var mySubclass = myContainer.Resolve<IMyObject>(myEnum.Value1.ToString()); 

例子统一： Implementing the Microsoft Unity (Dependency Injection) Design Pattern

当然你可以使用任何DI容器（温莎城堡，StructureMap，Ninject有，这是一个列表一些可用的。 .NET DI容器List of .NET Dependency Injection Containers (IOC)