C# 作为自身数据类型的整数集

我们都知道，在C#中，枚举类型不能用数字（整数）定义

e、 g.

public enum一些_整数{3,6,8,11}

是不可能的

所以我的问题是，我如何在C#中定义这样一种受限类型的整数（一些选定整数的集合）？ 换句话说，我想定义一个如下的变量：

private SOME_INTEGERS myVariable;

    public enum SOME_INTEGERS {
        One = 1,
        Three = 3,
        Five = 5
    }

    SOME_INTEGERS integer = SOME_INTEGERS.Three;
    Console.WriteLine((int)integer);//3

---

myVariable的值可能只有3、6、8或11。您可以使用以下内容：

private SOME_INTEGERS myVariable;

    public enum SOME_INTEGERS {
        One = 1,
        Three = 3,
        Five = 5
    }

    SOME_INTEGERS integer = SOME_INTEGERS.Three;
    Console.WriteLine((int)integer);//3

以下是一些选项：

// note that ((SomeIntegers)1) is a valid value with this scheme
public enum SomeIntegers { Three = 3, Six = 6, Eight = 8, Eleven = 11 }

// this stores the set of integers, but your logic to ensure the variable is
// one of these values must exist elsewhere, e.g. in property getters/setters
public ISet<int> SomeIntegers = new HashSet<int> {3,6,8,11};

// this class is a pseudo-enum, and with the exception of reflection,
// will ensure that only the specified values can be set
public sealed class SomeIntegers
{
    public static readonly SomeIntegers Three = new SomeIntegers(3);
    public static readonly SomeIntegers Six = new SomeIntegers(6);
    public static readonly SomeIntegers Eight = new SomeIntegers(8);
    public static readonly SomeIntegers Eleven = new SomeIntegers(11);
    public int Value { get; private set; }
    private SomeIntegers(int value)
    {
        this.Value = value;
    }
    public static implicit operator int(SomeIntegers someInteger)
    {
        return someInteger.Value;
    }
    public static explicit operator SomeIntegers(int value)
    {
        switch (value)
        {
            case 3:
                return Three;
            case 6:
                return Six;
            case 8:
                return Eight;
            case 11:
                return Eleven;
            default:
                throw new ArgumentException("Invalid value", "value");
        }
    }
    public override string ToString()
    {
        return this.Value.ToString();
    }
}

//注意（（SomeIntegers）1）是此方案的有效值
公共枚举一些整数{3=3，6=6，8=8，11=11}
//这将存储整数集，但您的逻辑将确保变量
//其中一个值必须存在于其他位置，例如在属性getter/setter中
公共ISet SomeIntegers=新哈希集{3,6,8,11}；
//这个类是一个伪枚举，除了反射，
//将确保只能设置指定的值
公共密封类整数
{
public static readonly SomeIntegers三=新的someinteger（3）；
public static readonly SomeIntegers六=新的SomeIntegers（6）；
public static readonly SomeIntegers八=新的someinteger（8）；
public static readonly SomeIntegers 11=新的SomeIntegers（11）；
公共int值{get；private set；}
私有整数（整数值）
{
这个。值=值；
}
公共静态隐式运算符int（SomeIntegers someInteger）
{
返回someInteger.Value；
}
公共静态显式运算符SomeInteger（int值）
{
开关（值）
{
案例3：
返回三个；
案例6：
返回六个；
案例8：
返回八个；
案例11：
返回11；
违约：
抛出新ArgumentException（“无效值”、“值”）；
}
}
公共重写字符串ToString（）
{
返回此.Value.ToString（）；
}
}

可能是一个结构：

struct MyInt
{
    static readonly int[] legalValues = { 3, 6, 8, 11 };

    public int Value
    {
        get;
        private set;
    }

    public bool IsIllegal
    {
        get
        {
            return Value == 0;
        }
    }

    MyInt(int value)
        : this()
    {
        Value = value;
    }

    public static implicit operator MyInt(int value)
    {
        if (legalValues.Contains(value))
        {
            return new MyInt(value);
        }

        return new MyInt();
    }
}

---

但是你可以创建非法值。

我不确定你想要什么，但是

数组

或

列表

？我想他想要我的变量是3,6,8或11中的一个int。如果是这样的话，一个带有验证构造函数的简单包装器类型就足够了。

枚举一些_整数{{u 3=3，{u 6=6，{u 8=8，{u 11=11}

看起来很难看，但这是您需要的吗？这里更大的问题是什么？听起来可能是XY的问题。你知道即使有这个“限制”，比如

myVariable=（一些整数）43241

将完全合法？这实际上并不限制值；某些整数仍然可以由任何

int

支持。例如，使用枚举，行

var x=（一些_整数）42可以正常工作。或者，如果值无效，您只需在运算符中抛出invalidcastexception，在构造函数中抛出异常。你不需要非法的解决方案，但我注意到<代码>新MyTimes（）/代码>将成为零。@鲍勃瓦尔，我考虑这个问题，但不是坏的做法抛出一个演员吗？@ EricLippert是的<代码>默认（MyIt）

是非法的，我会建议将演员设置为显式，而不是隐式，并抛出无效的CastException