下面是另一个有趣的想法，它可以满足Java中可用的自定义行为。我提出了以下枚举基类:

public abstract class Enumeration<T>
    where T : Enumeration<T>
{   
    protected static int nextOrdinal = 0;

    protected static readonly Dictionary<int, Enumeration<T>> byOrdinal = new Dictionary<int, Enumeration<T>>();
    protected static readonly Dictionary<string, Enumeration<T>> byName = new Dictionary<string, Enumeration<T>>();

    protected readonly string name;
    protected readonly int ordinal;

    protected Enumeration(string name)
        : this (name, nextOrdinal)
    {
    }

    protected Enumeration(string name, int ordinal)
    {
        this.name = name;
        this.ordinal = ordinal;
        nextOrdinal = ordinal + 1;
        byOrdinal.Add(ordinal, this);
        byName.Add(name, this);
    }

    public override string ToString()
    {
        return name;
    }

    public string Name 
    {
        get { return name; }
    }

    public static explicit operator int(Enumeration<T> obj)
    {
        return obj.ordinal;
    }

    public int Ordinal
    {
        get { return ordinal; }
    }
}

它有一个类型参数，所以序数计数可以在不同的派生枚举中正常工作。Jon Skeet对上面另一个问题(http://stackoverflow.com/questions/1376312/whats-the-equivalent-of-javas-enum-in-c)的回答中的运算符示例变成:

public class Operator : Enumeration<Operator>
{
    public static readonly Operator Plus = new Operator("Plus", (x, y) => x + y);
    public static readonly Operator Minus =  new Operator("Minus", (x, y) => x - y);
    public static readonly Operator Times =  new Operator("Times", (x, y) => x * y);
    public static readonly Operator Divide = new Operator("Divide", (x, y) => x / y);

    private readonly Func<int, int, int> op;

    // Prevent other top-level types from instantiating
    private Operator(string name, Func<int, int, int> op)
        :base (name)
    {
        this.op = op;
    }

    public int Execute(int left, int right)
    {
        return op(left, right);
    }
}

这带来了一些好处。

序数的支持 转换为字符串和int，这使得switch语句可行 GetType()将为派生的Enumeration类型的每个值提供相同的结果。 来自System的静态方法。枚举可以添加到基本枚举类以允许相同的功能。

我们刚刚为c#做了一个枚举扩展 https://github.com/simonmau/enum_ext

它只是一个afeenum类型的实现，但它工作得很好，所以我们做了一个包来分享-玩得开心

public sealed class Weekday : TypeSafeNameEnum<Weekday, int>
{
    public static readonly Weekday Monday = new Weekday(1, "--Monday--");
    public static readonly Weekday Tuesday = new Weekday(2, "--Tuesday--");
    public static readonly Weekday Wednesday = new Weekday(3, "--Wednesday--");
    ....

    private Weekday(int id, string name) : base(id, name)
    {
    }
}

Java枚举是一种语法糖，用于以面向对象的方式表示枚举。它们是在Java中扩展Enum类的抽象类，每个枚举值都类似于枚举类的静态最终公共实例实现。查看生成的类，对于包含10个值的枚举“Foo”，您将看到生成了“Foo$1”到“Foo$10”类。

虽然我不懂c#，但我只能推测，这种语言中的枚举更像C风格语言中的传统枚举。然而，我从一个快速的谷歌搜索中看到，它们可以保存多个值，因此它们可能以类似的方式实现，但限制比Java编译器所允许的要多得多。

在c#中，属性可以与枚举一起使用。这里是这个编程模式的一个很好的例子，有详细的描述(Codeproject)

public enum Planet
{
   [PlanetAttr(3.303e+23, 2.4397e6)]
   Mercury,
   [PlanetAttr(4.869e+24, 6.0518e6)]
   Venus
} 

编辑:这个问题最近被Jon Skeet再次提出并回答:在c#中，什么相当于Java的enum ? c#中的私有内部类——为什么不经常使用它们?

编辑2:看到公认的答案，它以一种非常聪明的方式扩展了这种方法!

您还可以为每个枚举类型使用一个实用程序类，该类包含每个枚举值的高级数据实例。

public enum Planet
{
    MERCURY,
    VENUS
}

public class PlanetUtil
{
    private static readonly IDictionary<Planet, PlanetUtil> PLANETS = new Dictionary<Planet, PlanetUtil();

    static PlanetUtil()
    {
        PlanetUtil.PLANETS.Add(Planet.MERCURY, new PlanetUtil(3.303e+23, 2.4397e6));
        PlanetUtil.PLANETS.Add(Planet.VENUS, new PlanetUtil(4.869e+24, 6.0518e6));
    }

    public static PlanetUtil GetUtil(Planet planet)
    {
        return PlanetUtil.PLANETS[planet];
    }

    private readonly double radius;
    private readonly double mass;

    public PlanetUtil(double radius, double mass)
    {
        this.radius = radius;
        this.mass = mass;
    }

    // getter
}

Java中的枚举比c#中的枚举复杂得多，因此功能更强大。 由于它只是另一种编译时语法糖，我想知道考虑到它在实际应用程序中的有限使用，是否真的值得包含该语言。 有时候，将一些东西排除在语言之外比屈服于包含一个小特性的压力更难。