Làm thế nào để kiểm tra một cách tao nhã nếu một số nằm trong một phạm vi?

Làm cách nào tôi có thể thực hiện việc này một cách thanh lịch với C # và .NET 3.5 / 4?

Ví dụ, một số có thể nằm trong khoảng từ 1 đến 100.

Tôi biết một đơn giản nếu sẽ đủ; nhưng từ khóa cho câu hỏi này là sự thanh lịch. Đó là cho dự án đồ chơi của tôi không dành cho sản xuất.

Câu hỏi này không phải là về tốc độ, mà là về vẻ đẹp mã. Ngừng nói về hiệu quả và như vậy; hãy nhớ rằng bạn đang giảng cho dàn hợp xướng.

Có rất nhiều lựa chọn:

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

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

Ngoài ra, kiểm tra bài SO này cho các tùy chọn regex.

Ý bạn là?

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

hoặc là

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

Chỉ cần thêm vào tiếng ồn ở đây, bạn có thể tạo một phương thức mở rộng:

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

Điều đó sẽ cho phép bạn làm một cái gì đó như ...

int val = 15;

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

Điều đó đang được nói, điều này có vẻ như là một điều ngớ ngẩn để làm khi bản thân kiểm tra chỉ là một dòng.

Như những người khác nói, sử dụng một đơn giản nếu.

Bạn nên suy nghĩ về việc đặt hàng.

ví dụ

1 <= x && x <= 100

dễ đọc hơn

x >= 1 && x <= 100

Trong mã sản xuất tôi chỉ đơn giản là viết

1 <= x && x <= 100

Điều này là dễ hiểu và rất dễ đọc.

Dưới đây là một phương pháp thông minh giúp giảm số lượng so sánh từ hai xuống một bằng cách sử dụng một số phép toán. Ý tưởng là một trong hai yếu tố trở thành âm nếu số nằm ngoài phạm vi và bằng 0 nếu số đó bằng một trong các giới hạn:

Nếu giới hạn được bao gồm:

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

hoặc là

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

Nếu giới hạn là độc quyền:

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

hoặc là

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

Tôi đề xuất này:

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

Ví dụ:

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

và tất nhiên với các biến:

myvalue.IsWithin(min, max)

Thật dễ đọc (gần với ngôn ngữ của con người) và hoạt động với bất kỳ loại so sánh nào (số nguyên, gấp đôi, loại tùy chỉnh ...).

Có mã dễ đọc là rất quan trọng vì nhà phát triển sẽ không lãng phí "chu kỳ não" để hiểu nó. Trong các phiên mã hóa dài, các chu kỳ não bị lãng phí khiến nhà phát triển mệt mỏi sớm hơn và dễ bị lỗi.

Với một chút lạm dụng phương thức mở rộng, chúng ta có thể có được giải pháp "thanh lịch" sau:

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!");
        }
    }
}

Nếu điều này là ngẫu nhiên, đơn giản iflà tất cả những gì bạn cần. Nếu điều này xảy ra ở nhiều nơi, bạn có thể muốn xem xét hai điều này:

• PostSharp . Trang trí các phương thức với các thuộc tính 'tiêm' mã vào phương thức sau khi biên dịch. Tôi không biết chắc chắn, nhưng tôi có thể tưởng tượng nó có thể được sử dụng cho việc này.

Cái gì đó như:

[Between("parameter", 0, 100)]
public void Foo(int parameter)
{
}

• Hợp đồng mã . Có lợi thế là các ràng buộc có thể được kiểm tra tại thời điểm biên dịch, bằng cách xác minh tĩnh mã của bạn và các địa điểm sử dụng mã của bạn.

if (value > 1 && value < 100)
{
    // do work
}
else
{
    // handle outside of range logic
}

Sử dụng một &&biểu thức để tham gia hai so sánh đơn giản là cách thanh lịch nhất để làm điều này. Nếu bạn thử sử dụng các phương thức mở rộng ưa thích và như vậy, bạn sẽ gặp phải câu hỏi là nên bao gồm giới hạn trên, giới hạn dưới hay cả hai. Khi bạn bắt đầu thêm các biến bổ sung hoặc thay đổi tên mở rộng để chỉ ra những gì được bao gồm, mã của bạn sẽ trở nên dài hơn và khó đọc hơn (đối với đại đa số các lập trình viên). Hơn nữa, các công cụ như Resharper sẽ cảnh báo bạn nếu so sánh của bạn không có ý nghĩa ( number > 100 && number < 1), điều mà họ sẽ không làm nếu bạn sử dụng một phương thức ('i.IsB between (100, 1)').

Nhận xét khác mà tôi đưa ra là nếu bạn đang kiểm tra đầu vào với ý định ném ngoại lệ, bạn nên xem xét sử dụng hợp đồng mã:

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

Điều này thanh lịch hơn if(...) throw new Exception(...), và bạn thậm chí có thể nhận được các cảnh báo về thời gian biên dịch nếu ai đó cố gắng gọi phương thức của bạn mà không đảm bảo rằng số đó nằm trong giới hạn trước.

Nếu bạn muốn viết nhiều mã hơn đơn giản, có lẽ bạn có thể: Tạo Phương thức tiện ích mở rộng có tên IsB between

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());

Phụ lục:Điều đáng chú ý là trong thực tế, bạn rất hiếm khi "chỉ kiểm tra sự bình đẳng" (hoặc <,>) trong một cơ sở mã. (Khác với những tình huống tầm thường nhất.) Hoàn toàn là một ví dụ, bất kỳ lập trình viên trò chơi nào cũng sẽ sử dụng các danh mục giống như sau trong mọi dự án, như một vấn đề cơ bản. Lưu ý rằng trong ví dụ này, nó (tình cờ) sử dụng một hàm (Mathf.Approimate) được xây dựng trong môi trường đó; trong thực tế, bạn thường phải phát triển một cách cẩn thận các khái niệm của riêng bạn về ý nghĩa so sánh đối với các biểu diễn trên máy tính của các số thực, cho loại tình huống bạn đang thiết kế. (Thậm chí đừng đề cập rằng nếu bạn đang làm một cái gì đó như, có thể là bộ điều khiển, bộ điều khiển PID hoặc tương tự, toàn bộ vấn đề trở thành trung tâm và rất khó khăn, nó trở thành bản chất của dự án.

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

Vì tất cả các câu trả lời khác không phải do tôi phát minh ra, đây chỉ là cách thực hiện của tôi:

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));
        }
    }
}

Sau đó bạn có thể sử dụng nó như thế này:

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

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

EDIT: Trả lời mới được cung cấp. Tôi mới bắt đầu sử dụng C # khi tôi viết câu trả lời đầu tiên cho câu hỏi này và sau khi nhận ra, bây giờ tôi nhận ra rằng "giải pháp" của tôi là / ngây thơ và không hiệu quả.

Câu trả lời ban đầu của tôi: Tôi sẽ dùng phiên bản đơn giản hơn:

if(Enumerable.Range(1,100).Contains(intInQuestion)) { ...DoStuff; }

Một cách tốt hơn

Vì tôi chưa thấy giải pháp nào hiệu quả hơn (ít nhất là theo thử nghiệm của tôi), tôi sẽ thử lại lần nữa.

Cách mới và tốt hơn cũng hoạt động với các phạm vi tiêu cực :

// 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);

Điều này có thể được sử dụng với cả phạm vi tích cực và tiêu cực và mặc định cho một phạm vi

1..100 (đã bao gồm) và sử dụng xlàm số để kiểm tra theo sau là một phạm vi tùy chọn được xác định bởi minvà max.

Thêm ví dụ cho biện pháp tốt

Ví dụ 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));

Trả về:

True
True
True
False
True

Ví dụ 2: Sử dụng danh sách các số nguyên ngẫu nhiên trong khoảng từ 1 đến 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);

Trả về:

66660 ints found in range 1..100

Thời gian thực hiện: 0,016 giây

Một sự pha trộn mới trong một khuynh hướng cũ:

public bool IsWithinRange(int number, int topOfRange, int bottomOfRange, bool includeBoundaries) {
    if (includeBoundaries)
        return number <= topOfRange && number >= bottomOfRange;
    return number < topOfRange && number > bottomOfRange;
}

Trong C, nếu hiệu quả thời gian là rất quan trọng và tràn số nguyên sẽ bao trùm, người ta có thể làm if ((unsigned)(value-min) <= (max-min)) .... Nếu 'max' và 'min' là các biến độc lập, phép trừ thêm cho (max-min) sẽ lãng phí thời gian, nhưng nếu biểu thức đó có thể được tính toán trước vào thời gian biên dịch hoặc nếu nó có thể được tính một lần vào thời gian chạy để kiểm tra nhiều lần các số so với cùng một phạm vi, biểu thức trên có thể được tính toán hiệu quả ngay cả trong trường hợp giá trị nằm trong phạm vi (nếu một phần lớn các giá trị sẽ nằm dưới phạm vi hợp lệ, có thể sử dụng nhanh hơn if ((value >= min) && (value <= max)) ...vì nó sẽ thoát sớm nếu giá trị nhỏ hơn phút).

Tuy nhiên, trước khi sử dụng một triển khai như vậy, điểm chuẩn của máy mục tiêu của một người. Trên một số bộ xử lý, biểu thức hai phần có thể nhanh hơn trong mọi trường hợp do hai phép so sánh có thể được thực hiện độc lập trong khi trong phương pháp trừ và so sánh, phép trừ phải hoàn thành trước khi phép so sánh có thể thực hiện.

Còn những thứ như thế này thì sao?

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

với phương pháp mở rộng như sau (đã thử nghiệm):

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

Tôi sẽ làm một đối tượng Range, đại loại như thế này:

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

Sau đó, bạn sử dụng nó theo cách này:

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

Bằng cách đó bạn có thể tái sử dụng nó cho loại khác.

Khi kiểm tra xem "Số" có nằm trong phạm vi không, bạn phải rõ ý của bạn là gì và hai số có nghĩa là gì? Nói chung, bạn nên bọc tất cả các số dấu phẩy động trong cái gọi là 'bóng epsilon', điều này được thực hiện bằng cách chọn một số giá trị nhỏ và nói nếu hai giá trị này gần nhau thì chúng là cùng một thứ.

    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);

Với hai người trợ giúp này và giả định rằng nếu có bất kỳ số nào có thể được gọi là gấp đôi mà không có độ chính xác cần thiết. Tất cả những gì bạn cần bây giờ là một enum và một phương thức khác

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

Phương pháp khác như sau:

    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");
        }
    }

Bây giờ điều này có thể nhiều hơn nhiều so với những gì bạn muốn, nhưng nó giúp bạn không phải làm việc suốt thời gian và cố gắng nhớ nếu một giá trị đã được làm tròn và đến nơi nào. Nếu bạn cần, bạn có thể dễ dàng mở rộng nó để hoạt động với bất kỳ epsilon nào và cho phép epsilon của bạn thay đổi.

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);
    }
}

Sử dụng

số képToBeChecked = 7;

var result = numberToBeChecked.IsB between (100.122);

kết quả var = 5.IsB between (100.120);

kết quả var = 8.0.IsB between (1.2.9.6);

Nếu bạn quan tâm đến nhận xét của @Daap về câu trả lời được chấp nhận và chỉ có thể chuyển giá trị một lần, bạn có thể thử một trong các cách sau

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

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

hoặc là

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

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

Về sự thanh lịch, điều gần gũi nhất với ký hiệu toán học ( a <= x <= b ) cải thiện một chút khả năng đọc:

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

Để minh họa thêm:

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

Tôi đang tìm kiếm một cách thanh lịch để làm điều đó trong đó giới hạn có thể được chuyển đổi (nghĩa là không chắc chắn các giá trị được đặt theo thứ tự nào).

Điều này sẽ chỉ hoạt động trên các phiên bản mới hơn của C # trong đó tồn tại ?:

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

Rõ ràng bạn có thể thay đổi các dấu = trong đó cho mục đích của bạn. Có thể nhận được ưa thích với loại đúc quá. Tôi chỉ cần một sự trở lại nổi trong giới hạn (hoặc bằng)

Thanh lịch bởi vì nó không yêu cầu bạn xác định giá trị nào trong hai giá trị biên trước lớn hơn. Nó cũng không chứa chi nhánh.

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 );
}

Tôi không biết nhưng tôi sử dụng phương pháp này:

    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));
}

Và đây là cách tôi có thể sử dụng nó:

    [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);
    }

Đây là một số phương pháp mở rộng có thể giúp

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

Nếu đó là để xác thực các tham số phương thức, không có giải pháp nào ném ArgumentOutOfRangeException và cho phép cấu hình dễ dàng / phù hợp các giá trị tối thiểu / tối thiểu bao gồm / độc quyền.

Sử dụng như thế này

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

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

Tôi chỉ viết những chức năng đẹp này. Nó cũng có lợi thế là không có phân nhánh (một nếu) cho các giá trị hợp lệ. Phần khó nhất là tạo các thông điệp ngoại lệ thích hợp.

/// <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);

Bạn đang tìm kiếm in [1..100]? Đó chỉ là Pascal.