1

我是 C# 新手，但我用 Java 做了很多编程。enum在 Java 中，您可以通过声明具有多个字段和私有构造函数的类来创建枚举对象类型（只有固定数量的可能值的类） 。例如，这个 Java 教程展示了如何创建一个枚举的“Planet”类型，它是一个对象（它有多个数据字段）但具有固定数量的值（只有 8 个行星，所以这个对象只有 8 个实例永远存在）。

但是，在 C# 中似乎没有任何方法可以做到这一点，因为enumC# 中的 s 只允许是原始类型，特别是数字原始类型。是否有任何简单的方法可以强制 C# 对象类型具有固定数量的可能实例值？或者我应该仅仅求助于某种单例模式/工厂模式架构，例如给类一个私有构造函数并定义一个固定数量的静态方法来返回一个有效实例？

4

3 回答 3

1

System.Drawing.Color就是这种事情的一个例子。

该Color类型具有类型的静态属性集合，Color可提供对命名颜色的访问。例如，System.Drawing.Color.CornflowerBlue。

该Color类型允许您创建一个Color不使用命名颜色的静态成员。如果你想禁止这个，你可以让你的类只有私有构造函数。那么访问您的类型实例的唯一方法是选择您的类型的可用静态属性之一。

于 2013-06-28T19:18:57.193 回答
0

您可以创建一个静态类，该类具有代表您的值的静态属性。这可能是最接近的。

public static class Planets
{
    // static cctor
    static Planets()
    {
        Saturn = new SaturnPlanet();
        Earth = new EarthPlanet();
        ...
    }

    public static Planet Saturn { get; private set; }
    public static Planet Earth { get; private set; }
    ...
}

您也可以选择在此处公开枚举器或 IEnumerable 方法或属性。

为了理智起见，您的Planets类以及它的所有属性对象（在本例中为Planet类型）应该是不可变的。否则你可能会遇到一些令人讨厌的多线程竞争条件。

于 2013-06-28T19:14:57.217 回答
0

枚举继承自 System.Enum 并且是密封的（不能从枚举继承）。进一步的枚举是整数类型（short、int、long 等）之上的语法糖。你可以这样做：

public enum Planet
{
    Mercury = 1 ,
    Venus   = 2 ,
    Earth   = 3 ,
    Mars    = 4 ,
    Jupiter = 5 ,
    Saturn  = 6 ,
    Uranus  = 7 ,
    Neptune = 8 ,
}
public interface IPlanetData
{
    double Mass   { get ; }
    double Radius { get ; }
}

public static class PlanetEnumHelpers
{
    private class PlanetData : IPlanetData
    {
        internal PlanetData( double mass , double radius )
        {
            Mass = mass ;
            Radius = radius ;
        }
        public double Mass   { get ; private set ; }
        public double Radius { get ; private set ; }
    }
    public static IPlanetData Data( this Planet planet )
    {
        IPlanetData instance ;

        switch ( planet )
        {
            case Planet.Mercury : instance = Mercury ; break ;
            case Planet.Venus   : instance = Venus   ; break ;
            case Planet.Earth   : instance = Earth   ; break ;
            case Planet.Mars    : instance = Mars    ; break ;
            case Planet.Jupiter : instance = Jupiter ; break ;
            case Planet.Saturn  : instance = Saturn  ; break ;
            case Planet.Uranus  : instance = Uranus  ; break ;
            case Planet.Neptune : instance = Neptune ; break ;
            default : throw new ArgumentOutOfRangeException("planet") ;
        }
        return instance ;
    }
    private static IPlanetData Mercury = new PlanetData( 3.303e+23 , 2.4397e6  ) ;
    private static IPlanetData Venus   = new PlanetData( 4.869e+24 , 6.0518e6  ) ;
    private static IPlanetData Earth   = new PlanetData( 5.976e+24 , 6.37814e6 ) ;
    private static IPlanetData Mars    = new PlanetData( 6.421e+23 , 3.3972e6  ) ;
    private static IPlanetData Jupiter = new PlanetData( 1.9e+27   , 7.1492e7  ) ;
    private static IPlanetData Saturn  = new PlanetData( 5.688e+26 , 6.0268e7  ) ;
    private static IPlanetData Uranus  = new PlanetData( 8.686e+25 , 2.5559e7  ) ;
    private static IPlanetData Neptune = new PlanetData( 1.024e+26 , 2.4746e7  ) ;
}
class Program
{
    static void Main( string[] args )
    {
        foreach ( Planet p in Enum.GetValues( typeof( Planet ) ) )
        {
            Console.WriteLine( "{0}: Mass={1} Radius={2}" , p , p.Data().Mass , p.Data().Radius );
        }
    }
}

这有点 hack，但保留了 Enum 的语义（例如，在switch语句中使用它的能力。

于 2013-06-28T19:44:25.257 回答