如何优雅地检查一个数字是否在一个范围内?

我如何用c#优雅地做到这一点?

例如，一个数字可以是1到100之间。

我知道一个简单的if (x >= 1 && x <= 100)就足够了;但是有很多语法糖和新特性不断添加到c# /。Net这个问题是关于更习惯的(一个可以称之为优雅的)写法。

性能不是问题，但请在非O(1)的解决方案中添加性能说明，因为人们可能会复制粘贴建议。

571792 次浏览
小开

你的意思是?

if(number >= 1 && number <= 100)

或

bool TestRange (int numberToCheck, int bottom, int top)
{
return (numberToCheck >= bottom && numberToCheck <= top);
}
小开

新花样的老最爱:

public bool IsWithinRange(int number, int topOfRange, int bottomOfRange, bool includeBoundaries) {
if (includeBoundaries)
return number <= topOfRange && number >= bottomOfRange;
return number < topOfRange && number > bottomOfRange;
}
小开 
if (value > 1 && value < 100)
{
// do work
}
else
{
// handle outside of range logic
}
小开

只是为了增加这里的噪音，你可以创建一个扩展方法:

public static bool IsWithin(this int value, int minimum, int maximum)
{
return value >= minimum && value <= maximum;
}

这样你就能做…

int val = 15;


bool foo = val.IsWithin(5,20);

话虽如此，当检查本身只有一行时，这样做似乎是一件愚蠢的事情。

小开
最佳答案

有很多选择:

int x = 30;
if (Enumerable.Range(1,100).Contains(x))  //true

实际上，基本的if可以在第一个检查中用倒序写得更优雅:

if (1 <= x && x <= 100)   //true

另外，查看所以文章中的正则表达式选项。

注:

  • LINQ解决方案严格适用于样式点-由于Contains迭代所有项，其复杂度为O(range_size)，而不是O(1)通常从范围检查中预期 其他范围的更通用版本(注意第二个参数是count，而不是end):

    if (Enumerable.Range(start, end - start + 1).Contains(x)
  • if的解决方案很容易像1 <= x <= 100那样没有&&，这样看起来很优雅，但在c#中会导致语法错误，“操作符”<=”不能应用于类型为“bool”和“int”的操作数;

小开

如果这是偶然的，你只需要一个简单的if。如果这种情况在很多地方都发生，你可能会考虑这两个:

  • PostSharp。在方法编译后，用“注入”代码的属性来装饰方法。我不确定，但我可以想象它可以用来做这个。

喜欢的东西:

[Between("parameter", 0, 100)]
public void Foo(int parameter)
{
}
  • 代码契约。优点是可以在编译时通过对代码和使用代码的地方进行静态验证来检查约束。
小开

就像其他人说的，使用简单的if。

你应该考虑一下顺序。

如

1 <= x && x <= 100

容易读吗

x >= 1 && x <= 100
小开

在C语言中，如果时间效率是至关重要的，整数溢出将被包裹，可以执行if ((unsigned)(value-min) <= (max-min)) ...。如果“max”和“最小值”是独立变量,额外的减法(极大极小)会浪费时间,但如果这可以在编译时预先计算的表达式,或者它可以在运行时计算一次测试许多数字相同的范围内,上述表达式可以计算效率即使在情况下,值范围内(如果值的很大一部分将在有效的范围,可能会更快的使用if ((value >= min) && (value <= max)) ...因为它将提前退出如果值小于最小值)。

不过，在使用这样的实现之前，请先对目标机器进行基准测试。在某些处理器上，由两部分组成的表达式可能在所有情况下都更快，因为两个比较可能是独立完成的，而在减法和比较方法中，减法必须在比较执行之前完成。

小开

通过一些扩展方法的滥用，我们可以得到以下“优雅”的解决方案:

using System;


namespace Elegant {
public class Range {
public int Lower { get; set; }
public int Upper { get; set; }
}


public static class Ext {
public static Range To(this int lower, int upper) {
return new Range { Lower = lower, Upper = upper };
}


public static bool In(this int n, Range r) {
return n >= r.Lower && n <= r.Upper;
}
}


class Program {
static void Main() {
int x = 55;
if (x.In(1.To(100)))
Console.WriteLine("it's in range! elegantly!");
}
}
}
小开

使用&&表达式连接两个比较是最优雅的方法。如果尝试使用花哨的扩展方法等，就会遇到是否包含上界、下界或两者都包含的问题。一旦您开始添加额外的变量或更改扩展名以表明包含了什么，您的代码就会变得更长且更难阅读(对于绝大多数程序员来说)。此外，Resharper等工具会在比较不合理的情况下警告你(number > 100 && number < 1)，如果你使用方法('i.IsBetween(100,1)')，它们就不会这样做。

我要做的唯一另一个评论是，如果你检查输入的意图是抛出异常，你应该考虑使用代码契约:

Contract.Requires(number > 1 && number < 100)

这比if(...) throw new Exception(...)更优雅，如果有人试图调用你的方法而没有确保数字是在边界内，你甚至可以得到编译时警告。

小开

我会创建一个Range对象，就像这样:

public class Range<T> where T : IComparable
{
public T InferiorBoundary{get;private set;}
public T SuperiorBoundary{get;private set;}


public Range(T inferiorBoundary, T superiorBoundary)
{
InferiorBoundary = inferiorBoundary;
SuperiorBoundary = superiorBoundary;
}


public bool IsWithinBoundaries(T value){
return InferiorBoundary.CompareTo(value) > 0 && SuperiorBoundary.CompareTo(value) < 0;
}
}

那么你可以这样使用它:

Range<int> myRange = new Range<int>(1,999);
bool isWithinRange = myRange.IsWithinBoundaries(3);

这样你就可以在其他类型中重用它。

小开
如果你想写更多的代码而不是简单的If，也许你可以: 创建名为IsBetween

的扩展方法 
public static class NumberExtensionMethods
{
public static bool IsBetween(this long value, long Min, long Max)
{
// return (value >= Min && value <= Max);
if (value >= Min && value <= Max) return true;
else return false;
}
}

.．.

// Checks if this number is between 1 and 100.
long MyNumber = 99;
MessageBox.Show(MyNumber.IsBetween(1, 100).ToString());

附录:值得注意的是，在实践中，你很少在代码库中“只是检查是否相等”(或<， >)。(除了最琐碎的情况。)纯粹作为一个例子，任何游戏程序员都会在每个项目中使用如下的分类。注意，在这个例子中，它(碰巧)使用了一个内置在该环境中的函数(Mathf.Approximately);在实践中，你通常必须仔细地发展自己的概念，对于计算机实数表示的比较意味着什么，对于你所设计的情况的类型。(更不用说，如果你在做控制器、PID控制器之类的东西，整个问题就会变得非常重要，非常困难，这是项目的本质。)这里的OP问题绝不是一个琐碎或不重要的问题。

private bool FloatLessThan(float a, float b)
{
if ( Mathf.Approximately(a,b) ) return false;
if (a<b) return true;
return false;
}


private bool FloatLessThanZero(float a)
{
if ( Mathf.Approximately(a,0f) ) return false;
if (a<0f) return true;
return false;
}


private bool FloatLessThanOrEqualToZero(float a)
{
if ( Mathf.Approximately(a,0f) ) return true;
if (a<0f) return true;
return false;
}
小开
  1. 在产品代码中，我会简单地写

    1 <= x && x <= 100

    这很容易理解，可读性很强。

  2. 从c# 9.0开始，我们可以编写

    x is >= 1 and <= 100
    注意，x只能写一次。is引入了一个模式匹配表达式，其中and是模式的一部分。 &&将要求我们重复x is，如x is >= 1 && x is <= 100

  3. Here is a clever method that reduces the number of comparisons from two to one by using some math. There is not necessarily a performance advantage in doing so, but it is elegant. The idea is that one of the two factors becomes negative if the number lies outside of the range and zero if the number is equal to one of the bounds:

    If the bounds are inclusive:

    (x - 1) * (100 - x) >= 0

    或

    (x - min) * (max - x) >= 0

    如果边界是排他的:

     (x - 1) * (100 - x) > 0

    或

    (x - min) * (max - x) > 0
小开

EDIT:提供新的答案。 当我写这个问题的第一个答案时，我刚刚开始使用c#，事后我意识到我的“解决方案”;

我原来的答案: 我会使用更简单的版本:

' if(Enumerable.Range(1100).Contains(intInQuestion)){…DoStuff;} " > < /罢工

更好的方法

因为我还没有看到任何其他更有效的解决方案(至少根据我的测试)，我将再试一次。

新的和更好的方法也适用于负范围:

// Returns true if x is in range [min..max], else false
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);

这可以用于正负范围，并且默认为

1 . . 100(包括)并使用x作为检查的数字，然后是由min和max定义的可选范围。

为好的措施添加例子

示例1:

// Returns true if x is in range [min..max], else false
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);


Console.WriteLine(inRange(25));
Console.WriteLine(inRange(1));
Console.WriteLine(inRange(100));
Console.WriteLine(inRange(25, 30, 150));
Console.WriteLine(inRange(-25, -50, 0));

返回:

True
True
True
False
True
< p >示例2: 使用100000个1到150之间的随机整数

的列表 
// Returns true if x is in range [min..max], else false
bool inRange(int x, int min=1, int max=100) => ((x - max)*(x - min) <= 0);


// Generate 100000 ints between 1 and 150
var intsToCheck = new List<int>();
var randGen = new Random();
for(int i = 0; i < 100000; ++i){
intsToCheck.Add(randGen.Next(150) + 1);
}


var counter = 0;
foreach(int n in intsToCheck) {
if(inRange(n)) ++counter;
}


Console.WriteLine("{0} ints found in range 1..100", counter);

返回:

66660 ints found in range 1..100


Execution Time: 0.016 second(s)
小开

像这样的怎么样?

if (theNumber.isBetween(low, high, IntEx.Bounds.INCLUSIVE_INCLUSIVE))
{
}

扩展方法如下(已测试):

public static class IntEx
{
public enum Bounds
{
INCLUSIVE_INCLUSIVE,
INCLUSIVE_EXCLUSIVE,
EXCLUSIVE_INCLUSIVE,
EXCLUSIVE_EXCLUSIVE
}


public static bool isBetween(this int theNumber, int low, int high, Bounds boundDef)
{
bool result;
switch (boundDef)
{
case Bounds.INCLUSIVE_INCLUSIVE:
result = ((low <= theNumber) && (theNumber <= high));
break;
case Bounds.INCLUSIVE_EXCLUSIVE:
result = ((low <= theNumber) && (theNumber < high));
break;
case Bounds.EXCLUSIVE_INCLUSIVE:
result = ((low < theNumber) && (theNumber <= high));
break;
case Bounds.EXCLUSIVE_EXCLUSIVE:
result = ((low < theNumber) && (theNumber < high));
break;
default:
throw new System.ArgumentException("Invalid boundary definition argument");
}
return result;
}
}
小开

因为所有其他答案都不是我发明的，这里只是我的实现:

public enum Range
{
/// <summary>
/// A range that contains all values greater than start and less than end.
/// </summary>
Open,
/// <summary>
/// A range that contains all values greater than or equal to start and less than or equal to end.
/// </summary>
Closed,
/// <summary>
/// A range that contains all values greater than or equal to start and less than end.
/// </summary>
OpenClosed,
/// <summary>
/// A range that contains all values greater than start and less than or equal to end.
/// </summary>
ClosedOpen
}


public static class RangeExtensions
{
/// <summary>
/// Checks if a value is within a range that contains all values greater than start and less than or equal to end.
/// </summary>
/// <param name="value">The value that should be checked.</param>
/// <param name="start">The first value of the range to be checked.</param>
/// <param name="end">The last value of the range to be checked.</param>
/// <returns><c>True</c> if the value is greater than start and less than or equal to end, otherwise <c>false</c>.</returns>
public static bool IsWithin<T>(this T value, T start, T end) where T : IComparable<T>
{
return IsWithin(value, start, end, Range.ClosedOpen);
}


/// <summary>
/// Checks if a value is within the given range.
/// </summary>
/// <param name="value">The value that should be checked.</param>
/// <param name="start">The first value of the range to be checked.</param>
/// <param name="end">The last value of the range to be checked.</param>
/// <param name="range">The kind of range that should be checked. Depending on the given kind of range the start end end value are either inclusive or exclusive.</param>
/// <returns><c>True</c> if the value is within the given range, otherwise <c>false</c>.</returns>
public static bool IsWithin<T>(this T value, T start, T end, Range range) where T : IComparable<T>
{
if (value == null)
throw new ArgumentNullException(nameof(value));


if (start == null)
throw new ArgumentNullException(nameof(start));


if (end == null)
throw new ArgumentNullException(nameof(end));


switch (range)
{
case Range.Open:
return value.CompareTo(start) > 0
&& value.CompareTo(end) < 0;
case Range.Closed:
return value.CompareTo(start) >= 0
&& value.CompareTo(end) <= 0;
case Range.OpenClosed:
return value.CompareTo(start) > 0
&& value.CompareTo(end) <= 0;
case Range.ClosedOpen:
return value.CompareTo(start) >= 0
&& value.CompareTo(end) < 0;
default:
throw new ArgumentException($"Unknown parameter value {range}.", nameof(range));
}
}
}

然后你可以这样使用它:

var value = 5;
var start = 1;
var end = 10;


var result = value.IsWithin(start, end, Range.Closed);
小开

我建议:

public static bool IsWithin<T>(this T value, T minimum, T maximum) where T : IComparable<T> {
if (value.CompareTo(minimum) < 0)
return false;
if (value.CompareTo(maximum) > 0)
return false;
return true;
}

例子:

45.IsWithin(32, 89)
true
87.2.IsWithin(87.1, 87.15)
false
87.2.IsWithin(87.1, 87.25)
true

当然还有变量:

myvalue.IsWithin(min, max)

它易于阅读(接近人类语言)，并适用于任何可比类型(整数，双精度，自定义类型……)。

让代码易于阅读是很重要的，因为开发人员不会浪费“大脑周期”去理解它。在长时间的编码过程中，浪费的大脑周期会使开发人员更早地疲劳并容易出现错误。

小开

我正在寻找一种优雅的方式来做它的边界可能被切换(即。不确定值的顺序)。

这只适用于存在?:的新版本的c#

bool ValueWithinBounds(float val, float bounds1, float bounds2)
{
return bounds1 >= bounds2 ?
val <= bounds1 && val >= bounds2 :
val <= bounds2 && val >= bounds1;
}

显然，您可以根据自己的需要更改=号。也可以用类型转换。我只需要在边界内(或等于)返回一个浮点数

小开

当检查一个“数字”是否在一个范围内时，你必须清楚你的意思，两个数字相等意味着什么?一般来说，你应该把所有浮点数包装在一个所谓的“epsilon球”中，这是通过选择一个小的值来完成的，如果两个值如此接近，它们就是相同的。

    private double _epsilon = 10E-9;
/// <summary>
/// Checks if the distance between two doubles is within an epsilon.
/// In general this should be used for determining equality between doubles.
/// </summary>
/// <param name="x0">The orgin of intrest</param>
/// <param name="x"> The point of intrest</param>
/// <param name="epsilon">The minimum distance between the points</param>
/// <returns>Returns true iff x  in (x0-epsilon, x0+epsilon)</returns>
public static bool IsInNeghborhood(double x0, double x, double epsilon) => Abs(x0 - x) < epsilon;


public static bool AreEqual(double v0, double v1) => IsInNeghborhood(v0, v1, _epsilon);

有了这两个辅助，并假设任何数字都可以转换为double而不需要所需的精度。现在需要的是一个枚举和另一个方法

    public enum BoundType
{
Open,
Closed,
OpenClosed,
ClosedOpen
}

另一种方法如下:

    public static bool InRange(double value, double upperBound, double lowerBound, BoundType bound = BoundType.Open)
{
bool inside = value < upperBound && value > lowerBound;
switch (bound)
{
case BoundType.Open:
return inside;
case BoundType.Closed:
return inside || AreEqual(value, upperBound) || AreEqual(value, lowerBound);
case BoundType.OpenClosed:
return inside || AreEqual(value, upperBound);
case BoundType.ClosedOpen:
return inside || AreEqual(value, lowerBound);
default:
throw new System.NotImplementedException("You forgot to do something");
}
}

现在，这可能远远超过了您想要的，但它使您不必一直处理舍入问题，并试图记住一个值是否被舍入到哪个位置。如果你需要，你可以很容易地将它扩展到任意的情况并允许变化。

小开

优雅是因为它不需要确定两个边界值中哪个先大。它也不包含分支。

public static bool InRange(float val, float a, float b)
{
// Determine if val lies between a and b without first asking which is larger (a or b)
return ( a <= val & val < b ) | ( b <= val & val < a );
}
小开

我不知道，但我用这个方法:

    public static Boolean isInRange(this Decimal dec, Decimal min, Decimal max, bool includesMin = true, bool includesMax = true ) {


return (includesMin ? (dec >= min) : (dec > min)) && (includesMax ? (dec <= max) : (dec < max));
}

这是我使用它的方式:

    [TestMethod]
public void IsIntoTheRange()
{
decimal dec = 54;


Boolean result = false;


result = dec.isInRange(50, 60); //result = True
Assert.IsTrue(result);


result = dec.isInRange(55, 60); //result = False
Assert.IsFalse(result);


result = dec.isInRange(54, 60); //result = True
Assert.IsTrue(result);


result = dec.isInRange(54, 60, false); //result = False
Assert.IsFalse(result);


result = dec.isInRange(32, 54, false, false);//result = False
Assert.IsFalse(result);


result = dec.isInRange(32, 54, false);//result = True
Assert.IsTrue(result);
}
小开

你正在寻找in [1..100]?这只是帕斯卡。

小开 
static class ExtensionMethods
{
internal static bool IsBetween(this double number,double bound1, double bound2)
{
return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
}


internal static bool IsBetween(this int number, double bound1, double bound2)
{
return Math.Min(bound1, bound2) <= number && number <= Math.Max(bound2, bound1);
}
}

使用

double numberToBeChecked = 7;

var result = numberToBeChecked.IsBetween(100,122);

var result = 5.IsBetween(100,120);

var result = 8.0.IsBetween(1.2,9.6);

小开

这些是一些可以提供帮助的扩展方法

  public static bool IsInRange<T>(this T value, T min, T max)
where T : System.IComparable<T>
{
return value.IsGreaterThenOrEqualTo(min) && value.IsLessThenOrEqualTo(max);
}




public static bool IsLessThenOrEqualTo<T>(this T value, T other)
where T : System.IComparable<T>
{
var result = value.CompareTo(other);
return result == -1 || result == 0;
}




public static bool IsGreaterThenOrEqualTo<T>(this T value, T other)
where T : System.IComparable<T>
{
var result = value.CompareTo(other);
return result == 1 || result == 0;
}
小开

如果您关心@Daap对已接受答案的注释，并且只能传递一次值，则可以尝试以下方法之一

bool TestRangeDistance (int numberToCheck, int bottom, int distance)
{
return (numberToCheck >= bottom && numberToCheck <= bottom+distance);
}


//var t = TestRangeDistance(10, somelist.Count()-5, 10);

或

bool TestRangeMargin (int numberToCheck, int target, int margin)
{
return (numberToCheck >= target-margin && numberToCheck <= target+margin);
}


//var t = TestRangeMargin(10, somelist.Count(), 5);
小开

关于优雅，最接近数学符号(A <= x <= b)的东西略微提高了可读性:

public static bool IsBetween(this int value, int min, int max)
{
return min <= value && value <= max;
}

为了进一步说明:

public static bool IsOutside(this int value, int min, int max)
{
return value < min || max < value;
}
小开

如果是为了验证方法参数，没有一个解决方案会抛出argumentoutofranceexception，并允许简单/适当地配置包含/排除的最小/最大值。

像这样使用

public void Start(int pos)
{
pos.CheckRange(nameof(pos), min: 0);


if (pos.IsInRange(max: 100, maxInclusive: false))
{
// ...
}
}

我只是写出了这些漂亮的函数。它还具有对有效值没有分支(单个if)的优点。最难的部分是制作适当的异常消息。

/// <summary>
/// Returns whether specified value is in valid range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>Whether the value is within range.</returns>
public static bool IsInRange<T>(this T value, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
where T : struct, IComparable<T>
{
var minValid = min == null || (minInclusive && value.CompareTo(min.Value) >= 0) || (!minInclusive && value.CompareTo(min.Value) > 0);
var maxValid = max == null || (maxInclusive && value.CompareTo(max.Value) <= 0) || (!maxInclusive && value.CompareTo(max.Value) < 0);
return minValid && maxValid;
}


/// <summary>
/// Validates whether specified value is in valid range, and throws an exception if out of range.
/// </summary>
/// <typeparam name="T">The type of data to validate.</typeparam>
/// <param name="value">The value to validate.</param>
/// <param name="name">The name of the parameter.</param>
/// <param name="min">The minimum valid value.</param>
/// <param name="minInclusive">Whether the minimum value is valid.</param>
/// <param name="max">The maximum valid value.</param>
/// <param name="maxInclusive">Whether the maximum value is valid.</param>
/// <returns>The value if valid.</returns>
public static T CheckRange<T>(this T value, string name, T? min = null, bool minInclusive = true, T? max = null, bool maxInclusive = true)
where T : struct, IComparable<T>
{
if (!value.IsInRange(min, minInclusive, max, maxInclusive))
{
if (min.HasValue && minInclusive && max.HasValue && maxInclusive)
{
var message = "{0} must be between {1} and {2}.";
throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, min, max));
}
else
{
var messageMin = min.HasValue ? GetOpText(true, minInclusive).FormatInvariant(min) : null;
var messageMax = max.HasValue ? GetOpText(false, maxInclusive).FormatInvariant(max) : null;
var message = (messageMin != null && messageMax != null) ?
"{0} must be {1} and {2}." :
"{0} must be {1}.";
throw new ArgumentOutOfRangeException(name, value, message.FormatInvariant(name, messageMin ?? messageMax, messageMax));
}
}
return value;
}


private static string GetOpText(bool greaterThan, bool inclusive)
{
return (greaterThan && inclusive) ? "greater than or equal to {0}" :
greaterThan ? "greater than {0}" :
inclusive ? "less than or equal to {0}" :
"less than {0}";
}


public static string FormatInvariant(this string format, params object?[] args) => string.Format(CultureInfo.InvariantCulture, format, args);
小开

您可以使用模式匹配以最优雅的方式实现这一点:

int i = 5;
if(i is (>0 and <=10))
{


}
小开

在c#中，关于速度和代码原的最佳解决方案，只有一次比较，没有约束检查，并且不会因溢出而容易出错:

public static bool IsInRange(int value, int min, int max) => (uint)(value - min) <= (uint)(max - min);

最小值和最大值包括在内。

小开

我使用下一个“优雅”的解决方案:

using static System.Linq.Enumerable;


int x = 30;
if (Range(1,100).Contains(x))  //true

来自微软文档

using static指令适用于任何具有静态成员(或嵌套类型)的类型，即使它也具有实例成员。但是，实例成员只能通过类型实例调用。

你可以访问一个类型的静态成员，而不需要用类型名限定访问:

但这对许多人来说并不简单，因为Enumerable.Range有第一个参数start和第二个参数count。 因此，这种检查可能在特定情况下有用，比如当你对foreach循环使用Enumerable.Range时，在开始之前，你想知道循环是否将被执行

例如:

        int count = 100;
int x = 30;


if (!Range(1, count).Contains(x)) {
Console.WriteLine("Do nothing!");
return;
}


foreach (var i in Range(1, count)) {
// Some job here
}
小开

使用内置的范围结构体(c# 8+)，我们可以创建一个扩展方法来检查Index是否在原始范围内。

public static bool IsInRangeOf(this Range range, Index index)
{
return index.Value >= range.Start.Value && index.Value < range.End.Value;
}

由于Index覆盖隐式操作符，因此可以传递int而不是Index结构体。

var range = new Range(1, 10);
var isInRange = range.IsInRangeOf(1); // true, 1..10 is inclusive min range index(1)
var isInRange = range.IsInRangeOf(10); // false, 1..10 exclusive on max range index (10).
var isInRange = range.IsInRangeOf(100); // false
小开

好吧，我会配合的。已经有这么多答案了，但也许还有一些其他新奇的空间:

(显然你根本不用这些)

    var num = 7;
const int min = 5;
const int max = 10;
var inRange = Math.Clamp(num, min, max) == num;

或

    var num = 7;
const int min = 5;
const int max = 10;
var inRange = num switch { < min => false, > max => false, _ => true };

或

    var num = 7;
const int min = 5;
const int max = 10;
var inRange = num is >= min and <= max;

好吧，也许你可以用最后一个。

好的，再来一个

    var num = 7;
const int min = 5;
const int max = 10;
var inRange = Enumerable.Range(min, max-min).Contains(num);
小开

2022年6月

int id = 10;
if(Enumerable.Range(1, 100).Select(x => x == id).Any()) // true

提交答案