C# 确定某个数字是否在指定的范围内

我正在寻找一种流畅的方法来确定一个数字是否在指定的范围内。我当前的代码如下所示：

int x = 500; // Could be any number

if ( ( x > 4199 && x < 6800 ) ||
     ( x > 6999 && x < 8200 ) ||
     ( x > 9999 && x < 10100 ) ||
     ( x > 10999 && x < 11100 ) ||
     ( x > 11999 && x < 12100 ) )
{
    // More awesome code
}

int x=500；//可以是任何号码
如果（（x>4199&&x<6800）||
（x>6999&&x<8200）||
（x>9999&&x<10100）||
（x>10999&&x<11100）||
（x>11999&&x<12100））
{
//更棒的代码
}

有更好的方法吗？

扩展方法

bool Between(this int value, int left, int right)
{ 
   return value > left && value < right; 
}

if(x.Between(4199, 6800) || x.Between(6999, 8200) || ...)

bool-Between（此int值，int-left，int-right）
{ 
返回值>左&&值<右；
}
如果（x.Between（41996800）| | x.Between（69998200）| |……）

你也可以做这个可怕的黑客：

bool Between(this int value, params int[] values)
{
    // Should be even number of items
    Debug.Assert(values.Length % 2 == 0); 

    for(int i = 0; i < values.Length; i += 2)
        if(!value.Between(values[i], values[i + 1])
            return false;

    return true;
}

if(x.Between(4199, 6800, 6999, 8200, ...)

bool-Between（此int值，参数int[]值）
{
//项目数应为偶数
Assert（values.Length%2==0）；
对于（int i=0；i

可怕的黑客，改进：

class Range
{
    int Left { get; set; }
    int Right { get; set; }

    // Constructors, etc.
}

Range R(int left, int right)
{
    return new Range(left, right)
}

bool Between(this int value, params Range[] ranges)
{
    for(int i = 0; i < ranges.Length; ++i)
        if(value > ranges[i].Left && value < ranges[i].Right)
            return true;

    return false;
}

if(x.Between(R(4199, 6800), R(6999, 8200), ...))

类范围
{
int Left{get；set；}
int Right{get；set；}
//施工人员等。
}
范围R（左整数，右整数）
{
返回新范围（左、右）
}
bool-Between（此int值，参数范围[]范围）
{
对于（int i=0；i范围[i]。左和值<范围[i]。右）
返回true；
返回false；
}
如果（x.Between（R（41996800），R（69998200），…）

或者更好（这不允许重复的下限）：

bool-Between（此int值，字典范围）
{
//基本上迭代键值对并检查值是否在该范围内
}
如果（x.Between（{41996800}，{69998200}，…}

定义一个范围类型，然后创建一组范围和一个扩展方法，以查看值是否位于任何范围内。然后，您可以创建一个范围集合，也许还有一些单独的范围，为它们提供有用的名称，以解释您对它们感兴趣的原因：

static readonly Range InvalidUser = new Range(100, 200);
static readonly Range MilkTooHot = new Range (300, 400);

static readonly IEnumerable<Range> Errors =
    new List<Range> { InvalidUser, MilkTooHot };

...

// Normal LINQ (where Range defines a Contains method)
if (Errors.Any(range => range.Contains(statusCode))
// or (extension method on int)
if (statusCode.InAny(Errors))
// or (extension methods on IEnumerable<Range>)
if (Errors.Any(statusCode))

---

（显然，这也使用了一些与DateTime/TimeSpan相关的扩展方法，但您知道了。）

如果您需要在某个时间点迭代值对，我建议您将最大下限值和最小上限值捕获到变量中，并执行以下操作：

if ( x>max_lower && x <min_upper)
{
    // More awesome code

}

if（x>max\u lower&&x尝试以下方法：

struct Range
{
   public readonly int LowerBound;
   public readonly int UpperBound; 

   public Range( int lower, int upper )
   { LowerBound = lower; UpperBound = upper; }

   public bool IsBetween( int value )
   { return value >= LowerBound && value <= UpperBound; }
}

public void YourMethod( int someValue )
{
   List<Range> ranges = {new Range(4199,6800),new Range(6999,8200),
                         new Range(9999,10100),new Range(10999,11100),
                         new Range(11999,12100)};

   if( ranges.Any( x => x.IsBetween( someValue ) )
   {
      // your awesome code...
   }
}

struct范围
{
公共只读int LowerBound；
公共只读int上限；
公共范围（整数下限、整数上限）
{LowerBound=下限；上限=上限；}
公共布尔值介于之间（int值）
{返回值>=LowerBound&&value x.IsBetween（someValue））
{
//你很棒的代码。。。
}
}
类别范围{
公共范围（整数x，整数y）{
X=X；
Y=Y；
}
公共整数X{get；set；}
公共整数Y{get；set；}
}
变量范围=新列表（）；
范围。添加（新范围（41996800））；
范围。添加（新范围（69998200））；
范围。添加（新范围（999910100））；
范围。添加（新范围（1099911100））；
增加（新范围（1199912100））；
bool inRange=ranges.Count（r=>x>=r.x&&x0；
//或者——根据乔恩的建议
bool inRange=ranges.Any（r=>x>=r.x&&x我个人更喜欢@Anton建议的扩展方法-但是如果你不能做到这一点，并且要坚持使用你当前的代码，我认为你可以通过如下颠倒每行的第一组条件来提高可读性

int x = 500; // Could be any number
if ( ( 4199 < x && x < 6800 ) ||
     ( 6999 < x && x < 8200 ) ||
     ( 9999 < x && x < 10100 ) ||
     ( 10999 < x && x < 11100 ) ||
     ( 11999 < x && x < 12100 ) )
{
    // More awesome code
}

int x=500；//可以是任何数字
如果（（4199
LINQ方法：

添加参考：

using System.Linq;

        /// <summary>
        /// Test to see if value is in specified range.
        /// </summary>
        /// <param name="aStart">int</param>
        /// <param name="aEnd">int</param>
        /// <param name="aValueToTest">int</param>
        /// <returns>bool</returns>
        public static bool CheckValueInRange(int aStart, int aEnd, int aValueToTest)
        {
            // check value in range...
            bool ValueInRange = Enumerable.Range(aStart, aEnd).Contains(aValueToTest);
            // return value...
            return ValueInRange;
        }

使用System.Linq；
/// 
///测试以查看值是否在指定范围内。
/// 
///int
///int
///int
///布尔
公共静态布尔校验值范围（int aStart、int aEnd、int aValueToTest）
{
//检查范围中的值。。。
bool ValueInRange=Enumerable.Range（aStart，aEnd）.Contains（aValueToTest）；
//返回值。。。
返回值范围；
}
在Pascal（Delphi）中，您有以下语句：

if x in [40..80] then
begin
end

因此，如果某个值x在该范围内，则执行命令。我正在寻找与此等效的C#，但找不到像这样简单且“优雅”的东西

这个if in（）then语句接受字符串、字节等。
在什么意义上更好？这看起来很不错reasonable@Michael当前位置我相信Steve要求的是一种更具说服力的方法。我认为您提供的示例是最好的（外观和可理解）老实说！我同意权力。除非你有一个庞大的数字列表，甚至可能是那样，否则我认为你的方式很容易阅读和理解。KISS。安东的第一个建议将是紧随其后的第二个。我喜欢这段代码，只要在每个&&语句周围放上括号就行了——不需要混乱。如果这不是不可能的呢？@ArsenMkrt，说如果那不是不可能呢？我不知道你在问什么，一般来说使用Any（）比Count（）好>0之后，它可以在找到匹配项后立即停止。感谢您的建议，我会将其添加到帖子中。我肯定会使范围不可变。对于这样的事情，易变性很糟糕…哇！注释中的格式设置！@Jon是的，您完全正确。CheckValueInRange只在范围的下限工作。因为En的第二个参数umerable.Range是要添加到序列中的值的数目（而不是范围的结尾），高于上限的值仍将作为范围中的值报告。例如：CheckValueInRange（419968006801）将返回True，尽管6801超出了所需的上限，因为Enumerable.Range（41996800）返回从4199到10998的数字范围
int x = 500; // Could be any number
if ( ( 4199 < x && x < 6800 ) ||
     ( 6999 < x && x < 8200 ) ||
     ( 9999 < x && x < 10100 ) ||
     ( 10999 < x && x < 11100 ) ||
     ( 11999 < x && x < 12100 ) )
{
    // More awesome code
}

using System.Linq;

        /// <summary>
        /// Test to see if value is in specified range.
        /// </summary>
        /// <param name="aStart">int</param>
        /// <param name="aEnd">int</param>
        /// <param name="aValueToTest">int</param>
        /// <returns>bool</returns>
        public static bool CheckValueInRange(int aStart, int aEnd, int aValueToTest)
        {
            // check value in range...
            bool ValueInRange = Enumerable.Range(aStart, aEnd).Contains(aValueToTest);
            // return value...
            return ValueInRange;
        }

if x in [40..80] then
begin
end