C# 泛型类型中静态字段的初始化

Question

我从this answer 了解到，C# 静态字段初始值设定项“在第一次使用该类的静态字段之前执行……”但这仍然会产生我没想到的结果，至少对于泛型类型.

来自 Java 世界，我想念我丰富的枚举，我认为使用 C# 的更重要的泛型，我应该能够用最少的样板来复制它们。这里（去掉了一些细节，比如可比性）是我想出的：

public class AbstractEnum<T> where T : AbstractEnum<T>
{
    static readonly IDictionary<String, T> nameRegistry = new Dictionary<String, T>();

    readonly String name;

    protected AbstractEnum (String name)
    {
        this.name = name;
        nameRegistry[name] = (T) this;
    }

    public String Name {
        get {
            return name;
        }
    }

    public static T ValueOf(String name) {
        return nameRegistry[name];
    }

    public static IEnumerable<T> Values {
        get {
            return nameRegistry.Values;
        }
    }
}

还有一些示例子类：

public class SomeEnum : AbstractEnum<SomeEnum> {

    public static readonly SomeEnum V1 = new SomeEnum("V1");
    public static readonly SomeEnum V2 = new SomeEnum("V2");

    SomeEnum(String name) : base(name) {

    }
}

public class OtherEnum : AbstractEnum<OtherEnum> {

    public static readonly OtherEnum V1 = new OtherEnum("V1");
    public static readonly OtherEnum V2 = new OtherEnum("V2");

    OtherEnum(String name) : base(name) {

    }
}

这看起来不错，而且或多或少有诀窍...除了按照规范的字母，实际实例（SomeEnum.V1、OtherEnum.V1 等）不会被初始化，除非至少有一个它们被明确提及。基类中的静态字段/方法不计算在内。因此，例如，以下内容：

Console.WriteLine("Count: {0}", SomeEnum.Values.Count());
foreach (SomeEnum e in SomeEnum.Values) {
    Console.WriteLine(e.Name);
}

写Count: 0，但如果我添加以下行--

Console.WriteLine("SomeEnum.V1: " + SomeEnum.V1.Name);

-- 甚至 以上，我得到：

Count: 2
V1
V2

（顺便提一下，在静态构造函数中初始化实例没有区别。）

现在，我可以通过将nameRegistry 标记为protected 并将Values 和ValueOf 推入子类来解决此问题，但我希望保持超类中的所有复杂性并将样板保持在最低限度。任何 C#-fu 优于我的人都可以想出一个使子类实例“自动执行”的技巧吗？

---

注意：FWIW，这是 Mac OS 上的 Mono。 YM 在 MS .NET 上，在 Windows 上，MV。

---

预计到达时间： 对于单语 C# 开发人员（甚至是经验仅限于以“C”开头的语言的多语言开发人员）想知道我正在尝试做的 WTF：this。 C# 枚举负责类型安全问题，但它们仍然缺少其他所有内容。

Answer 1

我想出了这个 - 并不完全令人愉悦，但确实可以完成工作：

        public static IEnumerable<T> Values
        {
            get
            {
                if (nameRegistry.Count > 0)
                {
                    return nameRegistry.Values;
                }
                var aField = typeof (T).GetFields(
                                        BindingFlags.Public | BindingFlags.Static)
                                    .FirstOrDefault();

                if (aField != null)
                    aField.GetValue(null);

                return nameRegistry.Values;
            }
        }

编辑这是一个稍微不同的版本，应该解决 VinayC 在 cmets 中的担忧。问题是这样的：线程 A 调用 Values()。当 SomeEnum 的静态构造函数运行时，在它添加 V1 之后但在添加 V2 之前，线程 B 调用值。在最初编写的代码中，它会被传递一个 IEnumerable，它可能只产生 V1。因此，如果第二个线程在第一次调用任何特定类型的 Values() 期间调用，您可能会从 Values() 得到不正确的结果。

以下版本使用布尔标志，而不是依赖 nameRegistry 中的非零计数。在这个版本中，反射代码仍然有可能多次运行，但不再可能从 Values() 中得到错误的答案，因为当反射代码完成时，nameRegistry 保证被完全初始化。

        private static bool _initialized;
        public static IEnumerable<T> Values
        {
            get
            {
                if (_initialized)
                {
                    return nameRegistry.Values;
                }
                var aField = typeof(T).GetFields(
                                            BindingFlags.Public | BindingFlags.Static)
                                        .FirstOrDefault();
                if (aField != null)
                    aField.GetValue(null);
                _initialized = true;
                return nameRegistry.Values;
            }
        }

Answer 2

诚然，我不知道 RichEnums 是什么，但是这个 C# 不能满足你的要求吗？

public enum SomeEnum
{
    V1,
    V2
}

class Program
{
    static void Main(string[] args)
    {
        var values = Enum.GetValues(typeof (SomeEnum));
        Console.WriteLine("Count: {0}", values.Length);
        foreach (SomeEnum e in values)
        {
            Console.WriteLine(e);
        }
    }
}

Answer 3

怎么样：

public class BaseRichEnum 
{
   public static InitializeAll()
   {
      foreach (Type t in Assembly.GetExecutingAssembly().GetTypes())
      {
        if (t.IsClass && !t.IsAbstract && typeof (BaseRichEnum).IsAssignableFrom(t))
        {
          t.GetMethod("Initialize").Invoke(null, null); //might want to use flags on GetMethod
        }
      }
   }
}

public class AbstractEnum<T> : BaseRichEnum where T : AbstractEnum<T>
{
    static readonly IDictionary<String, T> nameRegistry = new Dictionary<String, T>();

    readonly String name;

    protected AbstractEnum (String name)
    {
        this.name = name;
        nameRegistry[name] = (T) this;
    }

    public String Name {
        get {
            return name;
        }
    }

    public static T ValueOf(String name) {
        return nameRegistry[name];
    }

    public static IEnumerable<T> Values {
        get {
            return nameRegistry.Values;
        }
    }    
}

然后：

public class SomeEnum : AbstractEnum<SomeEnum> 
{

        public static readonly SomeEnum V1;
        public static readonly SomeEnum V2;

        public static void Initialize()
        {
          V1 = new SomeEnum("V1");
          V2 = new SomeEnum("V2"); 
        }

        SomeEnum(String name) : base(name) {
        }
    }

然后您必须在应用程序启动代码中调用 BaseRichEnum.InitializeAll()。我认为最好将这个简单的要求强加给客户端，从而使机制可见，而不是期望未来的维护者掌握静态时间初始化的微妙之处。

Answer 4

我不喜欢下面的解决方案，但是...

public class AbstractEnum<T> where T : AbstractEnum<T>
{
   ...
   private static IEnumerable<T> ValuesInternal {
        get {
            return nameRegistry.Values;
        }
   }

   public IEnumerable<T> Values {
     get {
       return ValuesInternal;
     }
   }
}

你必须使用SomeEnum.V1.Values - 我知道这很糟糕！ 另一个需要一些工作的替代方案是

public class AbstractEnum<T> where T : AbstractEnum<T>
{
   ...
   protected static IEnumerable<T> ValuesInternal {
        get {
            return nameRegistry.Values;
        }
   }
}

public class SomeEnum : AbstractEnum<SomeEnum> {
  ...

  public static IEnumerable<SomeEnum> Values
  {
    get
    {
        return ValuesInternal;
    }

  }
}

我会选择第二个选项。