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

Question

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

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

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 在 cmets 中指出的那样，您可以简单地使用框架提供的 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

枚举非常类似于关系数据库中的类型（或关联）表。它是一组选项列表，因此您可以限制一个值。如果您不熟悉关系数据库，则可能将枚举视为“选择列表”。枚举为我们提供了一个小的、有限的变量选择列表，而底层类型（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 没有您定义的每个枚举值的属性。 Red、Green 和 Blue 的值是您的枚举可能是的值。

您想要执行类似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

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

this.colour = c;

但是，您对“红色绿色和蓝色由 0-255 值表示”的评论让我有点困惑和担心。大多数颜色都会为红色绿色和蓝色中的每一个都有一个值，所以你不想要一个枚举。

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

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

所以我认为你可能在 Enums 上搞错了，可能你想要的是 Color 类。

您可能最不想做的就是拥有某种 Factory 类，它可以执行以下操作：

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

（对于混淆名称和使用颜色和颜色表示歉意）

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

Answer 7

也许 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;
}