下面是另一个有趣的想法，它可以满足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#中，属性可以与枚举一起使用。这里是这个编程模式的一个很好的例子，有详细的描述(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:看到公认的答案，它以一种非常聪明的方式扩展了这种方法!

Java枚举允许使用编译器生成的valueOf方法从名称进行简单的类型安全转换。

// Java Enum has generics smarts and allows this
Planet p = Planet.valueOf("MERCURY");

c#中等价的raw enum更详细:

// C# enum - bit of hoop jumping required
Planet p = (Planet)Enum.Parse(typeof(Planet), "MERCURY");

但是，如果按照Kent建议的方法，可以很容易地在枚举类中实现ValueOf方法。

我怀疑c#中的枚举只是CLR内部的常量，但不是很熟悉它们。我已经在Java中反编译了一些类，我可以告诉你想要的enum是一旦你转换。

Java做了一些狡猾的事情。它将枚举类视为一个普通类，在引用枚举值时使用大量宏。如果在使用枚举的Java类中有case语句，则它将枚举引用替换为整数。如果需要转到string，它会创建一个字符串数组，由它在每个类中使用的序数索引。我猜是为了节省拳击的费用。

如果你下载了这个反编译器，你会看到它如何创建它的类并集成它。说实话，相当吸引人。我过去不使用枚举类，因为我认为它对于一个常量数组来说太臃肿了。比起在c#中有限的使用方式，我更喜欢它。

http://members.fortunecity.com/neshkov/dj.html——Java反编译器

在c#中，你可以在枚举上定义扩展方法，这弥补了一些缺失的功能。

您可以将Planet定义为枚举，也可以使用与surfaceGravity()和surfaceWeight()等效的扩展方法。

我已经按照Mikhail的建议使用了自定义属性，但是使用Dictionary也可以达到同样的效果。

using System;
using System.Reflection;

class PlanetAttr: Attribute
{
    internal PlanetAttr(double mass, double radius)
    {
        this.Mass = mass;
        this.Radius = radius;
    }
    public double Mass { get; private set; }
    public double Radius { get; private set; }
}

public static class Planets
{
    public static double GetSurfaceGravity(this Planet p)
    {
        PlanetAttr attr = GetAttr(p);
        return G * attr.Mass / (attr.Radius * attr.Radius);
    }

    public static double GetSurfaceWeight(this Planet p, double otherMass)
    {
        return otherMass * p.GetSurfaceGravity();
    }

    public const double G = 6.67300E-11;

    private static PlanetAttr GetAttr(Planet p)
    {
        return (PlanetAttr)Attribute.GetCustomAttribute(ForValue(p), typeof(PlanetAttr));
    }

    private static MemberInfo ForValue(Planet p)
    {
        return typeof(Planet).GetField(Enum.GetName(typeof(Planet), p));
    }

}

public enum Planet
{
    [PlanetAttr(3.303e+23, 2.4397e6)]  MERCURY,
    [PlanetAttr(4.869e+24, 6.0518e6)]  VENUS,
    [PlanetAttr(5.976e+24, 6.37814e6)] EARTH,
    [PlanetAttr(6.421e+23, 3.3972e6)]  MARS,
    [PlanetAttr(1.9e+27,   7.1492e7)]  JUPITER,
    [PlanetAttr(5.688e+26, 6.0268e7)]  SATURN,
    [PlanetAttr(8.686e+25, 2.5559e7)]  URANUS,
    [PlanetAttr(1.024e+26, 2.4746e7)]  NEPTUNE,
    [PlanetAttr(1.27e+22,  1.137e6)]   PLUTO
}

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