Як елегантно перевірити, чи число в межах діапазону?

Як я можу це зробити елегантно за допомогою C # і .NET 3.5 / 4?

Наприклад, число може бути від 1 до 100.

Я знаю просте, якби це було достатньо; але ключовим словом цього питання є елегантність. Це для мого іграшкового проекту не для виробництва.

Ці питання стосувалися не швидкості, а краси краси. Перестаньте говорити про ефективність та таке; пам'ятайте, що ви проповідували хору.

Варіантів дуже багато:

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

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

Крім того, ознайомтеся з цією публікацією SO щодо варіантів регулярних виразів.

Ти маєш на увазі?

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

або

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

Просто для додання тут шуму ви можете створити метод розширення:

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

Це, мабуть, здається дурною справою, коли перевірка є лише одним рядком.

Як говорили інші, використовуйте простий, якщо.

Вам варто подумати про замовлення.

напр

1 <= x && x <= 100

легше читати, ніж

x >= 1 && x <= 100

У виробничому коді я просто напишу

1 <= x && x <= 100

Це легко зрозуміти і дуже легко читати.

Ось розумний метод, який зменшує кількість порівнянь з двох до одного, використовуючи деяку математику. Ідея полягає в тому, що один з двох факторів стає негативним, якщо число лежить поза діапазоном і дорівнює нулю, якщо число дорівнює одному з меж:

Якщо межі включені:

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

або

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

Якщо межі є ексклюзивними:

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

або

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

Я пропоную це:

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)

Це легко читати (близьке до людської мови) і працює з будь-яким порівнянним типом (цілі, подвійні, спеціальні типи ...).

Важливим є читання коду, оскільки розробник не витрачає "мозкові цикли" на його розуміння. Під час тривалих сеансів кодування витрачені мозкові цикли змушують розробника втомитися раніше і схильні до помилок.

Дещо зловживаючи методом розширення, ми можемо отримати таке «елегантне» рішення:

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

Якщо це випадково, ifвсе, що вам потрібно , є простим . Якщо це трапляється в багатьох місцях, ви можете розглянути ці два:

• PostSharp . Прикрасьте методи атрибутами, які 'вводять' код у метод після компіляції. Я точно не знаю, але можу уявити, що це можна використовувати для цього.

Щось на зразок:

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

• Код контрактів . Перевагою є те, що обмеження можна перевірити під час компіляції за допомогою статичної перевірки коду та місць, у яких використовується ваш код.

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

Використовувати &&вираз для з'єднання двох порівнянь - це просто найелегантніший спосіб зробити це. Якщо ви спробуєте скористатися фантазійними методами розширення і подібними, ви стикаєтеся з питанням, чи включати верхню межу, нижню межу чи обидва. Після того, як ви почнете додавати додаткові змінні або змінювати імена розширень, щоб вказати, що включено, ваш код стає довшим і важчим для читання (для переважної більшості програмістів). Крім того, такі інструменти, як Resharper, попередить вас, якщо порівняння не має сенсу (number > 100 && number < 1 ), чого вони не зроблять, якщо ви використовуєте метод ('i.IsBet Between (100, 1)').

Єдиний інший коментар, який я хочу зробити, - це те, що якщо ви перевіряєте матеріали з наміром скинути виняток, вам слід розглянути можливість використання кодових контрактів

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

Це більш елегантно, ніж if(...) throw new Exception(...)ви навіть можете отримати попередження за час компіляції, якщо хтось спробує зателефонувати за вашим методом, не впевнившись, що число в першу чергу знаходиться в межах.

Якщо ви хочете написати більше коду, ніж простий, якщо, можливо, ви можете: Створіть метод розширення під назвою 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-контролер тощо), вся проблема стає центральною і дуже складною, вона набуває характер проекту.

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

Тому що вся інша відповідь не придумана мною, ось лише моя реалізація:

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

EDIT: Новий відповідь надано. Я тільки починав використовувати C #, коли писав першу відповідь на це запитання, і зараз, розуміючи, моє "рішення" було / є наївним та неефективним.

Моя оригінальна відповідь: Я б пішов з більш простою версією:

if(Enumerable.Range(1,100).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

Приклад 2: Використання списку випадкових вводів між 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

Час виконання: 0.016 секунд

Новий поворот старого улюбленого:

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

У C, якщо ефективність часу є вирішальним, а цілі переливи завершаться, можна було б зробити if ((unsigned)(value-min) <= (max-min)) .... Якщо 'max' і 'min' є незалежними змінними, додаткове віднімання для (max-min) буде витрачати час, але якщо це вираження може бути попередньо обчислено під час компіляції, або якщо його можна обчислити один раз під час виконання для тестування багатьох Чисел проти того ж діапазону, вищевказаний вираз може бути обчислений ефективно навіть у тому випадку, коли значення знаходиться в межах діапазону (якщо велика частка значень буде нижче допустимого діапазону, його можна використовувати швидше, if ((value >= min) && (value <= max)) ...оскільки воно вийде рано, якщо значення менше, ніж хв).

Перш ніж використовувати таку реалізацію, проте, орієнтир орієнтовної машини. У деяких процесорах вираз з двох частин може бути швидшим у всіх випадках, оскільки два порівняння можуть бути виконані незалежно, тоді як у методі віднімання та порівняння віднімання має завершитися, перш ніж порівняння може виконатись.

Як щодо чогось подібного?

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

Я б зробив об'єкт 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);

Таким чином ви можете повторно використовувати його для іншого типу.

Перевіряючи, чи "Число" знаходиться в діапазоні, вам повинно бути зрозуміло, що ви маєте на увазі, а що означають два числа, рівні? Загалом, ви повинні зафіксувати всі числа з плаваючою комою у тому, що називається "куля-епсілон", це робиться шляхом вибору деякого невеликого значення і кажучи, якщо два значення є такими близькими, то це одне і те ж.

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

З цими двома помічниками на місці та припускаючи, що якщо будь-яке число можна подати як подвійне без необхідної точності. Тепер все, що вам знадобиться, - це перерахунок та інший метод

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

Тепер це може бути набагато більше того, що ви хотіли, але це перешкоджає вам постійно займатися округленням і намагатися запам'ятати, чи було значення округлене і до якого місця. Якщо вам потрібно, ви можете легко розширити це для роботи з будь-яким епсилоном і дозволити вашому епсилону змінюватися.

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

Використання

подвійне числоToBeChecked = 7;

var результат = числоToBeChecked.IsBet Between (100,122);

var результат = 5.IsBet between (100,120);

var результат = 8.0.IsBet between (1.2,9.6);

Якщо ви стурбовані коментарем @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;
}

Я шукав елегантний спосіб зробити це там, де перемикаються межі (тобто не знаю, в якому порядку знаходяться значення).

Це буде працювати лише на новіших версіях C #, де існує:?:

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

Очевидно, ви можете змінити знаки = там для своїх цілей. Можливо, захоплюєтесь і типом лиття. Мені просто потрібно було повернути поплавок в межах (або дорівнює)

Елегантний, тому що він не вимагає від вас визначати, яке з двох граничних значень перше більше. Він також не містить гілок.

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

Ось деякі методи розширення, які можуть допомогти

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

Якщо потрібно перевірити параметри методу, жодне з рішень не кидає ArgumentOutOfRangeException і дозволяє легко / правильну конфігурацію включно / ексклюзивних значень min / max.

Використовуйте так

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

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

Я просто написав ці прекрасні функції. Також має перевагу відсутність розгалуження (єдиного, якщо) для дійсних значень. Найважче - створити відповідні повідомлення про виключення.

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

Ви шукаєте in [1..100]? Це тільки Паскаль.