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>>，而不是将类型添加为值，而是添加包装每个类的构造函数并将其作为对象返回的函数。 / p>

编辑：我正在添加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

另一种解决方案是使用依赖注入（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());

使用Unity的示例： Implementing the Microsoft Unity (Dependency Injection) Design Pattern

当然你可以使用任何DI容器（Castle Windsor，StructureMap，Ninject。这里列出了一些可用的.NET DI容器List of .NET Dependency Injection Containers (IOC)

Answer 5

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

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

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

如果每个枚举的值可以连接在一起，则会将选择过程缩减为单个switch语句。这可能最好通过连接，相乘或相加枚举值来实现 - 但它们如何连接在一起取决于枚举，并且在不知道更多细节的情况下很难提供更明确的方向。

如何在C＃中使用自定义属性来替换交换机中的交换机？

5 个答案: