Question

我正在使用我正在使用的方法的范围，而我的经理要求我使用Enum而不是整数，所以不要这样：

public virtual int MyMethod(int value)
    {
        int result = 0;

        if (value >= 0 && value <= 3333)
        {
            result = 1;
        }
        else if (value >= 3334 && value <= 6666)
        {
            result = 2;
        }
        else if (value >= 6667 && value <= 10000)
        {
            result = 3;
        }
        return result;
    }

我使用这样的东西：

public virtual int MyMethod(int value)
    {
        int result = 0;

        if (value >= (int)EnumClass.Range.Low.Min && value <= (int)EnumClass.Range.Low.Max)
        {
            result = 1;
        }
        else if (value >= (int)EnumClass.Range.Medium.Min && value <= (int)EnumClass.Range.Medium.Max)
        {
            result = 2;
        }
        else if (value >= (int)EnumClass.Range.High.Min && value <= (int)EnumClass.Range.High.Max)
        {
            result = 3;
        }
        return result;
    }

EnumClass有其他Enum用于其他方法（即评级，优先级），所以我希望Range保持自己的变量，有点像这样：

public static enum Rating
    {
        Low = 1,
        Medium,
        High
    };

public static enum[] Range =
    {
        enum Low
        {
            Min = 0,
            Max = 3333
        },

        enum Medium
        {
            Min = 3334,
            Max = 6666
        },

        enum High
        {
            Min = 6667,
            Max = 10000
        }  
    };

我在初始化该数组时遇到错误，但是，有没有其他方法可以实现这一点？如果可能的话，我想避免让他们成为三个Enum，但如果这是不可避免的，我会用这个：

public static enum Rating
    {
        Low = 1,
        Medium,
        High
    };
public static enum RangeLow
    {
        Min = 0,
        Max = 3333
    };
public static enum RangeMedium
    {
        Min = 3334,
        Max = 6666
    };
public static enum RangeHigh
    {
        Min = 6667,
        Max = 10000
    };

Answer 1

我认为静态常量方法非常简单，但它也消耗了大量代码，并且很难立即使用。这是一种更紧凑的替代方法 - 静态列表比一堆else-if语句更简单明了：

// The various thresholds from your previous if statement.
var list = new List<int>() { 0, 3333, 6666, 10000 };
var min  = list.First();
var max  = list.Last();

现在你可以做到：

return (value >= min && value <= max) ?
  list.TakeWhile(p => p < value).Count() :
  0;

（PS为什么你的经理会决定是否使用枚举等实施决策，特别是当这是一个非常有问题的用法？除非你做了一些非常严重的错误，这感觉就像是一些相当严厉的微观管理。）

Answer 2

听起来你想要常量或静态只读，而不是枚举。下面未经测试的代码，但这应该如下工作：var foo = Range.Low.Min;

public static class EnumClass 
{
    public static class Range
    {
        public static class Low
        {
            public static readonly int Min = 0;
            public static readonly int Max = 3333;
        }

        public static class Medium
        {
            public static readonly int Min = 3334;
            public static readonly int Max = 6666;
        }

        public static class High
        {
            public static readonly int Min = 6667;
            public static readonly int Max = 10000;
        }  
    }
}

那就是说，像this CodeProject article中描述的Range类更适合你的用例。

Answer 3

你被问到（或者更糟，被告知）用扳手砸钉子。它会起作用，但它是令人不快的，这对于枚举来说并不合适，正如已经提到的那样。

我建议如果这是一个常见的应用程序，定义一个范围并检查它，那么你将Range封装在一个类中（这可能只是一对最小值和最大值的属性，以及方法用于检查范围内的值等等，然后使用它。

你能创建一个枚举值数组吗？

3 个答案: