Question

我可能会以错误的方式看待Enums但是想确保我对如何使用它们有正确的理论。

假设我们有一个名为Color的枚举。

enum Colour { Red, Green, Blue };

红色绿色和蓝色由0-255个值表示。我试图在类形状中初始化这个枚举，我不确定如何去做。

public class Shape
{

    Colour colour;

    public Shape(Colour c)
    {
         //Some attempts at initialization.


         //Treating It like an object
         this.colour = 
            c{
                255,255,255
            };

         //Again
         this.colour.Red = c.Red
         this.colour.Blue = c.Blue
         this.colour.Green = c.Green

         Colour.red = c.red?


         }
    }
}

就我如何思考枚举而言，我可能已经离开了。谁能给我一些指示？

Answer 1

在这种情况下，您可能希望Color为struct而不是枚举。在C＃中，枚举是单值构造，但您有三个值（红色，绿色和蓝色）。以下是我可能会做的事情：

public struct Colour 
{
    private byte red;
    private byte green;
    private byte blue;

    public Colour(byte r, byte g, byte b) 
    {
        this.red = r;
        this.green = g;
        this.blue = b;
    }
}

public class Shape
{
    public Colour Colour { get; private set; }

    public Shape(Colour c)
    {
        this.Colour = c;
    }
}

然后当你创建形状对象时：

var shape = new Shape(new Colour(203, 211, 48));

编辑：正如Chris在评论中指出的那样，您可以简单地使用框架提供的System.Drawing.Color结构。上面的例子将简化为：

using System.Drawing;

public class Shape
{
    public Color Colour { get; private set; }

    public Shape(Color c)
    {
        this.Colour = c;
    }
}

var shape = new Shape(Color.FromArgb(203, 211, 48));

Answer 2

枚举非常类似于关系数据库中的类型（或关联）表。它是一组选项，因此您可以约束值。如果您不熟悉关系数据库，可以将枚举想象成一个“选择列表”。 Enums为变量提供了一个小的，有限的选择列表，而底层类型（int，byte等）要大得多。

完成正在尝试的方法的常用方法是测试枚举值，然后设置对象：

switch(c)
{
   case Colour.Red:
        //Set up red shape here
        break;
   //etc ...
}

Answer 3

this.colour = Colour.Red; // or Colour.Green or whatever

this.colour属于Colour类型，只能取三个值中的一个。将Colour视为类似Integer的类型，但它可以只取三个值中的一个，而Integer可以取Integer.MIN_VALUE..Integer.MAX_VALUE范围内的任何一个值。

如果您尝试构建RGB颜色，那么这不是正确的方法。在这种情况下，您正在寻找一个名为Colour的类，它的red, green and blue组件具有不同的值。

Answer 4

您的枚举Colour没有您定义的每个枚举值的属性。红色，绿色和蓝色值是您的枚举可能的值。

您希望执行this.colour = Colour.Red之类的操作，将colour变量设置为红色值。然后，在代码的后面，如果您只想根据值是否为红色触发某些代码，您可以执行以下操作：

if(this.colour == Colour.Red)
{
// Do red specific logic
}

Answer 5

你最好使用不可变结构：

public struct Colour
{
    private readonly byte red;

    private readonly byte green;

    private readonly byte blue;

    public Colour(byte red, byte green, byte blue)
    {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }

    public byte Red
    {
        get
        {
            return this.red;
        }
    }

    public byte Green
    {
        get
        {
            return this.green;
        }
    }

    public byte Blue
    {
        get
        {
            return this.blue;
        }
    }
}

你可以这样初始化它：

Shape shape = new Shape(new Colour(104, 255, 67));

Answer 6

也许您正在寻找type-safe枚举。它们允许标准枚举更丰富的行为。

public sealed class Colour
{
  public int RedComponent { get; private set;}
  public int GreenComponent { get; private set;}
  public int BlueComponent { get; private set;}

  public static readonly Colour Red = new Colour(255,0,0);

  private Colour(int red, int green, int blue)
  {
    RedComponent = red;
    GreenComponent = green;
    BlueComponent = blue;
  }
}

然后，您可以使用方法Foo(Colour c){//Do something with c.RedComponent etc.}并致电Foo(Colour.Red)

您甚至可以按正常枚举比较值：

Bar(Colour c)
{
  return c == Colour.Red;
}

Answer 7

如果颜色是你的枚举，那么你在构造函数中需要做的就是：

this.colour = c;

然而，我对你的评论感到有点困惑和担忧，“红绿蓝代表0-255价值”。大多数颜色都有红色绿色和蓝色的值，所以你不需要枚举。

类似于下拉框，可以最容易地想到枚举。有一组固定值，您的选择必须是其中之一，而不是其他。下拉列表背后可能有一个值，但通常你会想知道下拉列表是否显示“红色”，而不是它背后的价值是什么。这样做的原因是，通常使用Enums，你只会说“If（color = Colour.Red）然后......”。

你正在做的事情听起来更像是.NET Class Color（由美国人命名，这可能是你没有找到它的原因，如果这是你想要的）。这具有R，G，B的属性以及将返回Color类的预定义实例（例如Color.Red）的一组静态属性将返回具有适当RGB集的Color实例。

所以我认为你可能在枚举上得到了错误的结果，可能你想要的是Color类。

你可能想要的最后一件事是拥有某种类似于：

的Factory类

public Color CreateColor(Colour colEnum)
{
    switch(colEnum)
    case Colour.Red:
    return Color.Red;
    etc.
}

（对于混淆名称和使用颜色和颜色道歉）

这可以确保您根据枚举获得颜色，并且只有枚举中定义的颜色才能以这种方式创建。

在类构造函数中初始化枚举的正确方法

7 个答案: