c# vs Java Enum(适合c#新手)

我已经用Java编程了一段时间，刚刚被扔到一个完全用c#编写的项目上。我正在努力赶上c#的速度，并注意到在我的新项目中有几个地方使用了枚举，但乍一看，c#的枚举似乎比Java 1.5+实现更简单。任何人都可以列举c#和Java枚举之间的差异，以及如何克服这些差异?(我不想开始一场语言大战，我只是想知道如何用c#做一些我过去用Java做的事情)。例如，有人可以发布一个与Sun著名的Planet枚举示例对应的c#版本吗?

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


private final double mass;   // in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
public double mass()   { return mass; }
public double radius() { return radius; }


// universal gravitational constant  (m3 kg-1 s-2)
public static final double G = 6.67300E-11;


public double surfaceGravity() {
return G * mass / (radius * radius);
}
public double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
}


// Example usage (slight modification of Sun's example):
public static void main(String[] args) {
Planet pEarth = Planet.EARTH;
double earthRadius = pEarth.radius(); // Just threw it in to show usage


// Argument passed in is earth Weight.  Calculate weight on each planet:
double earthWeight = Double.parseDouble(args[0]);
double mass = earthWeight/pEarth.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}


// Example output:
$ java Planet 175
Your weight on MERCURY is 66.107583
Your weight on VENUS is 158.374842
[etc ...]
75431 次浏览
小开
最佳答案

CLR中的枚举被简单命名为常量。基础类型必须是整型。在Java中，枚举更像是类型的命名实例。该类型可能相当复杂，并且—如您的示例所示—包含多个不同类型的字段。

为了将这个例子移植到c#，我只需要将枚举更改为一个不可变的类，并公开该类的静态只读实例:

using System;
using System.Collections.Generic;


namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Planet planetEarth = Planet.MERCURY;


double earthRadius = pEarth.Radius; // Just threw it in to show usage
double earthWeight = double.Parse("123");
double earthMass   = earthWeight / pEarth.SurfaceGravity();


foreach (Planet p in Planet.Values)
Console.WriteLine($"Your weight on {p} is {p.SurfaceWeight(mass)}");


Console.ReadKey();
}
}


public class Planet
{
public static readonly Planet MERCURY = new Planet("Mercury", 3.303e+23, 2.4397e6);
public static readonly Planet VENUS   = new Planet("Venus", 4.869e+24, 6.0518e6);
public static readonly Planet EARTH   = new Planet("Earth", 5.976e+24, 6.37814e6);
public static readonly Planet MARS    = new Planet("Mars", 6.421e+23, 3.3972e6);
public static readonly Planet JUPITER = new Planet("Jupiter", 1.9e+27, 7.1492e7);
public static readonly Planet SATURN  = new Planet("Saturn", 5.688e+26, 6.0268e7);
public static readonly Planet URANUS  = new Planet("Uranus", 8.686e+25, 2.5559e7);
public static readonly Planet NEPTUNE = new Planet("Neptune", 1.024e+26, 2.4746e7);
public static readonly Planet PLUTO   = new Planet("Pluto", 1.27e+22, 1.137e6);


public static IEnumerable<Planet> Values
{
get
{
yield return MERCURY;
yield return VENUS;
yield return EARTH;
yield return MARS;
yield return JUPITER;
yield return SATURN;
yield return URANUS;
yield return NEPTUNE;
yield return PLUTO;
}
}


public string Name   { get; private set; }
public double Mass   { get; private set; }
public double Radius { get; private set; }


Planet(string name, double mass, double radius) =>
(Name, Mass, Radius) = (name, mass, radius);


// Wniversal gravitational constant  (m3 kg-1 s-2)
public const double G = 6.67300E-11;
public double SurfaceGravity()            => G * mass / (radius * radius);
public double SurfaceWeight(double other) => other * SurfaceGravity();
public override string ToString()         => name;
}
}
小开

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

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

小开

Java枚举实际上是一个完整的类，可以有一个私有构造函数和方法等，而c#枚举只是命名的整数。IMO Java的实现要优越得多。

当你从java营地学习c#时，这个页面应该会对你有很大的帮助。(链接指向关于枚举的差异(向上/向下滚动查看其他内容)

小开

我想是这样的:

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


public class Planet
{
public double Mass {get;private set;}
public double Radius {get;private set;}


Planet(double mass, double radius)
{
Mass = mass;
Radius = radius;
}


// universal gravitational constant  (m3 kg-1 s-2)
private static readonly double G = 6.67300E-11;


public double SurfaceGravity()
{
return G * Mass / (Radius * Radius);
}


public double SurfaceWeight(double otherMass)
{
return otherMass * SurfaceGravity();
}
}

或者像上面那样将常量组合到Planet类中

小开

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#中，属性可以与枚举一起使用。有详细描述的这种编程模式的一个很好的例子是在这里 (Codeproject)

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

编辑:这个问题最近被Jon Skeet再次提出并回答: c#中与Java's enum等价的是什么? c#中的私有内部类——为什么它们不被更多地使用呢? < / p >

编辑2:看到接受的答案以一种非常出色的方式扩展了这种方法!

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

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

你可以将Planet定义为一个枚举，也可以有等价于surfaceGravity()和surfaceWeight()的扩展方法。

我已经使用了米哈伊尔•所建议的自定义属性，但同样可以使用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
}
小开

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

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

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

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

小开

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

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的Operator例子来自他对上面另一个问题(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);
}
}

这带来了一些好处。

  • 序数的支持
  • 转换为string和int，使switch语句可行
  • GetType()将为派生的Enumeration类型的每个值提供相同的结果。
  • System.Enum中的Static方法可以添加到基本枚举类中，以允许相同的功能。
小开 
//Review the sample enum below for a template on how to implement a JavaEnum.
//There is also an EnumSet implementation below.


public abstract class JavaEnum : IComparable {
public static IEnumerable<JavaEnum> Values {
get {
throw new NotImplementedException("Enumeration missing");
}
}


public readonly string Name;


public JavaEnum(string name) {
this.Name = name;
}


public override string ToString() {
return base.ToString() + "." + Name.ToUpper();
}


public int CompareTo(object obj) {
if(obj is JavaEnum) {
return string.Compare(this.Name, ((JavaEnum)obj).Name);
} else {
throw new ArgumentException();
}
}




//Dictionary values are of type SortedSet<T>
private static Dictionary<Type, object> enumDictionary;
public static SortedSet<T> RetrieveEnumValues<T>() where T : JavaEnum {
if(enumDictionary == null) {
enumDictionary = new Dictionary<Type, object>();
}
object enums;
if(!enumDictionary.TryGetValue(typeof(T), out enums)) {
enums = new SortedSet<T>();
FieldInfo[] myFieldInfo = typeof(T).GetFields(BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Public);
foreach(FieldInfo f in myFieldInfo) {
if(f.FieldType == typeof(T)) {
((SortedSet<T>)enums).Add((T)f.GetValue(null));
}
}
enumDictionary.Add(typeof(T), enums);
}
return (SortedSet<T>)enums;
}
}




//Sample JavaEnum
public class SampleEnum : JavaEnum {
//Enum values
public static readonly SampleEnum A = new SampleEnum("A", 1);
public static readonly SampleEnum B = new SampleEnum("B", 2);
public static readonly SampleEnum C = new SampleEnum("C", 3);


//Variables or Properties common to all enums of this type
public int int1;
public static int int2 = 4;
public static readonly int int3 = 9;


//The Values property must be replaced with a call to JavaEnum.generateEnumValues<MyEnumType>() to generate an IEnumerable set.
public static new IEnumerable<SampleEnum> Values {
get {
foreach(var e in JavaEnum.RetrieveEnumValues<SampleEnum>()) {
yield return e;
}
//If this enum should compose several enums, add them here
//foreach(var e in ChildSampleEnum.Values) {
//    yield return e;
//}
}
}


public SampleEnum(string name, int int1)
: base(name) {
this.int1 = int1;
}
}




public class EnumSet<T> : SortedSet<T> where T : JavaEnum {
// Creates an enum set containing all of the elements in the specified element type.
public static EnumSet<T> AllOf(IEnumerable<T> values) {
EnumSet<T> returnSet = new EnumSet<T>();
foreach(T item in values) {
returnSet.Add(item);
}
return returnSet;
}


// Creates an enum set with the same element type as the specified enum set, initially containing all the elements of this type that are not contained in the specified set.
public static EnumSet<T> ComplementOf(IEnumerable<T> values, EnumSet<T> set) {
EnumSet<T> returnSet = new EnumSet<T>();
foreach(T item in values) {
if(!set.Contains(item)) {
returnSet.Add(item);
}
}
return returnSet;
}


// Creates an enum set initially containing all of the elements in the range defined by the two specified endpoints.
public static EnumSet<T> Range(IEnumerable<T> values, T from, T to) {
EnumSet<T> returnSet = new EnumSet<T>();
if(from == to) {
returnSet.Add(from);
return returnSet;
}
bool isFrom = false;
foreach(T item in values) {
if(isFrom) {
returnSet.Add(item);
if(item == to) {
return returnSet;
}
} else if(item == from) {
isFrom = true;
returnSet.Add(item);
}
}
throw new ArgumentException();
}


// Creates an enum set initially containing the specified element(s).
public static EnumSet<T> Of(params T[] setItems) {
EnumSet<T> returnSet = new EnumSet<T>();
foreach(T item in setItems) {
returnSet.Add(item);
}
return returnSet;
}


// Creates an empty enum set with the specified element type.
public static EnumSet<T> NoneOf() {
return new EnumSet<T>();
}


// Returns a copy of the set passed in.
public static EnumSet<T> CopyOf(EnumSet<T> set) {
EnumSet<T> returnSet = new EnumSet<T>();
returnSet.Add(set);
return returnSet;
}


// Adds a set to an existing set.
public void Add(EnumSet<T> enumSet) {
foreach(T item in enumSet) {
this.Add(item);
}
}


// Removes a set from an existing set.
public void Remove(EnumSet<T> enumSet) {
foreach(T item in enumSet) {
this.Remove(item);
}
}
}
小开

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

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
}
小开

我们刚刚为c#做了一个enum扩展 https://github.com/simonmau/enum_ext < / p >

它只是一个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)
{
}
}

提交答案