Question

过去几周，我以curiously recurring template模式给自己带来了一些麻烦。

继续我的这两个问题：

What’s the correct way of retrieving my custom enumeration classes by their value?
Why are my static objects not being instantiated when first access to the static class is a static method on the base class?

如何改进以下示例：

public class DocketType : Enumeration<DocketType, int, string>
{
    public static DocketType Withdrawal = new DocketType(2, "Withdrawal");
    public static DocketType Installation = new DocketType(3, "Installation");

    private DocketType(int docketTypeId, string description) 
        : base(docketTypeId, description) { }
}

我想要一个静态方法，我不必在Enumeration类中重复：

public abstract class Enumeration<TEnum, X, Y> : IComparable 
    where TEnum : Enumeration<TEnum, X, Y> 
{        
    protected Enumeration(X value, Y displayName)
    {
        AddToStaticCache(this);
    }
    public static TEnum Resolve(X value)
    {
        return Cache[value] as TEnum;
    }
}

正如您在第二个链接问题中看到的那样，问题在于对Enumeration<DocketType, int, string>.Resolve(X value);的调用不会导致DocketType静态对象被实例化。

我并不反对完全从头开始重写。我知道这是一个很大的代码味道。目前，为了使这个工作，我的基类具有受保护的静态方法ChildResolve，并且我已经为每个Enumeration类添加了Resolve。讨厌的东西！

解答：

似乎没有替代模式，所以我坚持使用模式并从接受的答案中获取灵感，并提出了这个：

static Enumeration()
{
    GetAll();
}

public static void GetAll()
{
    var type = typeof(TEnum);
    var fields = type.GetFields(BindingFlags.Public | 
        BindingFlags.Static | BindingFlags.DeclaredOnly);

    foreach (var info in fields)
    {
        var locatedValue = info.GetValue(null) as Enumeration<TEnum, X, Y>;
        Cache.Add(locatedValue.Value, locatedValue);
    }
}

这也是在CodeCampServer MVC示例项目中使用的相同代码，所以我觉得使用它不那么脏！

Answer 1

这不是很优雅，但是这样的事情可能会起到作用：

public class DocketType : Enumeration<DocketType, int, string>
{
    public static readonly DocketType Withdrawal =
        new DocketType(2, "Withdrawal");

    public static readonly DocketType Installation =
        new DocketType(3, "Installation");

    private DocketType(int docketTypeId, string description)
        : base(docketTypeId, description) { }
}

public abstract class Enumeration<TEnum, TId, TDescription> : IComparable
    where TEnum : Enumeration<TEnum, TId, TDescription>
{
    private static readonly Dictionary<TId, TEnum> _cache;

    static Enumeration()
    {
        Type t = typeof(TEnum);
        _cache = t.GetFields(BindingFlags.Public | BindingFlags.Static)
                  .Where(f => f.FieldType == t)
                  .Select(f => (TEnum)f.GetValue(null))
                  .ToDictionary(e => e.Id, e => e);
    }

    public static TEnum Resolve(TId id)
    {
        return _cache[id];
    }

    public TId Id { get; private set; }
    public TDescription Description { get; private set; }

    protected Enumeration(TId id, TDescription description)
    {
        Id = id;
        Description = description;
    }

    // IComparable
    public int CompareTo(object obj)
    {
        // TODO
        throw new NotImplementedException();
    }
}

Answer 2

您需要将静态字段推送到具有静态实例作为实例字段的类中。这样您就可以通过一个静态成员访问枚举，该成员立即实例化所有枚举成员。

一个快速抛出的例子：

// The Collection of values to be enumerated
public class DocketEnum : EnumarationCollection<DocketType, int, string>
{
        // Values are fields on a statically instanced version of this class
    public DocketType Withdrawal = new DocketType(2, "Withdrawal");
    public DocketType Installation = new DocketType(3, "Installation");

    // The publicly accessible static enumeration 
    public static DocketEnum Values = new DocketEnum();
}

// The actual value class
public class DocketType : EnumerationValue<DocketType, int, string>
{
        // Call through to the helper base constructor
    public DocketType(int docketTypeId, string description) 
        : base(docketTypeId, description) { }
}

// Base class for the enumeration
public abstract class EnumarationCollection<TType, X, Y>
    where TType : EnumerationValue<TType, X, Y> 
{
            // Resolve looks at the static Dictionary in the base helpers class
    public TType Resolve(X value)
    {
        return Cache[value] as TType;
    }

    public static Dictionary<X, EnumerationValue<TType, X, Y> > Cache = new Dictionary<X, EnumerationValue<TType, X, Y>>();
}

// Base class for the value
public abstract class EnumerationValue<TType, X, Y> 
    where TType : EnumerationValue<TType, X, Y> 
{        
        // helper constructer talks directly the the base helper class for the Enumeration
    protected EnumerationValue(X value, Y displayName)
    {
        EnumarationCollection<TType, X,Y >.Cache.Add(value, this as TType);
    }
}



class MainClass
{
    public static void Main (string[] args)
    {
                    // You can immediately resolve to the enumeration
        Console.WriteLine(DocketEnum.Values.Resolve(2).ToString());
    }
}

Answer 3

你想对某个给定类型的所有子类做一些事情。如果不使用AppDomain.Current.GetAssemblies（）并迭代它们，那么任何这种性质都是不可能的。如果采用这种方法，可以通过创建仅应用于程序集的程序集级别属性（以及应包含在子类搜索中的其他程序）来优化性能。并在准备调用时使用它.GetTypes（）在每个集会上。

要清楚，这里有一个示例，说明了获取所有这些子类的内容：

Type[] subclasses = AppDomain.CurrentDomain.GetAssemblies()
    .Where(x => Attribute.IsDefined(typeof(MyEnumeartionAssemblyAttribute)))
    .SelectMany(x => x.GetTypes())
    .Where(x => x.BaseType != null && 
           x.BaseType.IsGenericType && 
           x.BaseType.GetGenericTypeDefinition() == typeof(Enumeration<,,>));

从那里开始，应该只是在每个System.Type上使用反射并使用静态字段执行操作。

Answer 4

如果你想强制运行另一个类的静态构造函数，可以使用RuntimeHelpers.RunClassConstructor。您可以从Enumeration<TEnum, X, Y>的静态构造函数中调用它，以便在第一次在泛型类型的任何实例化中使用静态方法时运行它：

static Enumeration()
{
    RuntimeHelpers.RunClassConstructor(typeof(TEnum).TypeHandle);
}

是否有奇怪的重复模板模式的替代品？

4 个答案: