¿Cómo verificar con elegancia si un número está dentro de un rango?

¿Cómo puedo hacer esto con elegancia con C # y .NET 3.5 / 4?

Por ejemplo, un número puede estar entre 1 y 100.

Sé que un simple si sería suficiente; pero la palabra clave para esta pregunta es elegancia. Es para mi proyecto de juguete, no para producción.

Estas preguntas no se referían a la velocidad, sino a la belleza del código. Deja de hablar de eficiencia y tal; recuerda que estás predicando al coro.

Hay muchas opciones:

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

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

Además, consulte esta publicación SO para ver las opciones de expresiones regulares.

¿Quieres decir?

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

o

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

Solo para agregar al ruido aquí, podría crear un método de extensión:

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

Lo que te permitiría hacer algo como ...

int val = 15;

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

Dicho esto, esto parece una tontería cuando el cheque en sí es solo una línea.

Como otros dijeron, use un simple if.

Debes pensar en el pedido.

p.ej

1 <= x && x <= 100

es más fácil de leer que

x >= 1 && x <= 100

En el código de producción simplemente escribiría

1 <= x && x <= 100

Esto es fácil de entender y muy legible.

Aquí hay un método inteligente que reduce el número de comparaciones de dos a uno mediante el uso de algunas matemáticas. La idea es que uno de los dos factores se vuelve negativo si el número se encuentra fuera del rango y cero si el número es igual a uno de los límites:

Si los límites son inclusivos:

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

o

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

Si los límites son exclusivos:

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

o

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

Propongo esto:

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

Ejemplos:

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

y por supuesto con variables:

myvalue.IsWithin(min, max)

Es fácil de leer (cercano al lenguaje humano) y funciona con cualquier tipo comparable (entero, doble, tipos personalizados ...).

Tener un código fácil de leer es importante porque el desarrollador no desperdiciará "ciclos cerebrales" para comprenderlo. En largas sesiones de codificación, los ciclos cerebrales desperdiciados hacen que el desarrollador se canse antes y sea propenso a errores.

Con un poco de abuso del método de extensión, podemos obtener la siguiente solución "elegante":

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

Si esto es incidental, un simple ifes todo lo que necesita. Si esto sucede en muchos lugares, es posible que desee considerar estos dos:

• PostSharp . Decora métodos con atributos que 'inyectan' código en el método después de la compilación. No estoy seguro, pero me imagino que se puede usar para esto.

Algo como:

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

• Código de contratos . Tiene la ventaja de que las restricciones se pueden verificar en tiempo de compilación, mediante la verificación estática de su código y los lugares que usan su código.

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

Usar una &&expresión para unir dos comparaciones es simplemente la forma más elegante de hacerlo. Si intenta utilizar métodos de extensión sofisticados y demás, se encontrará con la pregunta de si incluir el límite superior, el límite inferior o ambos. Una vez que comience a agregar variables adicionales o cambie los nombres de las extensiones para indicar qué está incluido, su código se vuelve más largo y difícil de leer (para la gran mayoría de los programadores). Además, herramientas como Resharper te avisarán si tu comparación no tiene sentido (number > 100 && number < 1 ), lo que no harán si utiliza un método ('i.IsBetween (100, 1)').

El único otro comentario que haría es que si está verificando entradas con la intención de lanzar una excepción, debería considerar usar contratos de código:

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

Esto es más elegante que if(...) throw new Exception(...), e incluso podría obtener advertencias en tiempo de compilación si alguien intenta llamar a su método sin asegurarse de que el número esté dentro de los límites primero.

Si desea escribir más código que un simple if, tal vez pueda: Crear un Método de extensión llamado 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());

Apéndice:Vale la pena señalar que en la práctica rara vez "simplemente verifica la igualdad" (o <,>) en una base de código. (Aparte de en las situaciones más triviales). Simplemente como ejemplo, cualquier programador de juegos usaría categorías como las siguientes en cada proyecto, como una cuestión básica. Tenga en cuenta que en este ejemplo (resulta ser) que usa una función (Mathf. Aproximadamente) que está integrada en ese entorno; En la práctica, normalmente tiene que desarrollar cuidadosamente sus propios conceptos de lo que significan las comparaciones para las representaciones de números reales por computadora, para el tipo de situación que está diseñando. (Ni siquiera mencione que si está haciendo algo como, tal vez un controlador, un controlador PID o similar, todo el problema se vuelve central y muy difícil, se convierte en la naturaleza del proyecto.

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

Porque todas las otras respuestas no las inventé yo, aquí solo mi implementación:

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

Luego puede usarlo así:

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

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

EDITAR: Nueva respuesta proporcionada. Estaba comenzando a usar C # cuando escribí la primera respuesta a esta pregunta, y en retrospectiva ahora me doy cuenta de que mi "solución" era / es ingenua e ineficiente.

Mi respuesta original: iría con la versión más simple:

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

Una mejor manera

Como no he visto ninguna otra solución que sea más eficiente (al menos según mis pruebas), lo intentaré de nuevo.

Nueva y mejor manera que también funciona con rangos negativos :

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

Esto se puede usar con rangos positivos y negativos y los valores predeterminados para un rango de

1..100 (inclusive) y se utiliza xcomo número para verificar seguido de un rango opcional definido por miny max.

Agregar ejemplos de buena medida

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

Devoluciones:

True
True
True
False
True

Ejemplo 2: uso de una lista de entradas aleatorias entre 1 y 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);

Devoluciones:

66660 ints found in range 1..100

Tiempo de ejecución: 0.016 segundo (s)

Un nuevo giro en un viejo favorito:

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

En C, si la eficiencia del tiempo es crucial y se desbordan los desbordamientos de enteros, se podría hacer if ((unsigned)(value-min) <= (max-min)) .... Si 'max' y 'min' son variables independientes, la resta adicional para (max-min) perderá tiempo, pero si esa expresión puede calcularse previamente en tiempo de compilación, o si puede calcularse una vez en tiempo de ejecución para probar muchas números contra el mismo rango, la expresión anterior se puede calcular de manera eficiente incluso en el caso de que el valor esté dentro del rango (si una gran fracción de valores estará por debajo del rango válido, puede ser más rápido de usar if ((value >= min) && (value <= max)) ...porque saldrá temprano si el valor es menos de min).

Sin embargo, antes de usar una implementación como esa, evalúe la máquina de destino de uno. En algunos procesadores, la expresión de dos partes puede ser más rápida en todos los casos ya que las dos comparaciones se pueden hacer de forma independiente, mientras que en el método de restar y comparar la resta tiene que completarse antes de que la comparación pueda ejecutarse.

¿Qué tal algo como esto?

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

con el método de extensión de la siguiente manera (probado):

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

Haría un objeto Range, algo como esto:

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

Luego lo usas de esta manera:

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

De esa manera puedes reutilizarlo para otro tipo.

Al verificar si un "Número" está en un rango, debe ser claro en lo que quiere decir, y ¿qué significan dos números iguales? En general, debe envolver todos los números de coma flotante en lo que se llama una 'bola épsilon'. Esto se hace seleccionando un valor pequeño y diciendo que si dos valores están tan cerca, son lo mismo.

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

Con estos dos ayudantes en su lugar y suponiendo que si algún número se puede lanzar como doble sin la precisión requerida. Todo lo que necesitará ahora es una enumeración y otro método

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

El otro método sigue:

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

Ahora, esto puede ser mucho más de lo que quería, pero le impide tratar de redondear todo el tiempo y tratar de recordar si un valor se ha redondeado y a qué lugar. Si lo necesita, puede extenderlo fácilmente para trabajar con cualquier épsilon y permitir que su épsilon cambie.

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

Uso

double numberToBeChecked = 7;

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

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

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

Si le preocupa el comentario de @Daap sobre la respuesta aceptada y solo puede pasar el valor una vez, puede intentar uno de los siguientes

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

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

o

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

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

En cuanto a la elegancia, lo más parecido a la notación matemática ( a <= x <= b ) mejora ligeramente la legibilidad:

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

Para más ilustración:

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

Estaba buscando una manera elegante de hacerlo donde los límites podrían cambiarse (es decir, no estoy seguro en qué orden están los valores).

Esto solo funcionará en versiones más nuevas de C # donde el?: Existe

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

Obviamente, podría cambiar los signos = allí para sus propósitos. Podría ser elegante con el tipo de casting también. Solo necesitaba un retorno flotante dentro de los límites (o igual a)

Elegante porque no requiere que determine cuál de los dos valores límite es mayor primero. Tampoco contiene ramas.

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

No lo sé pero uso este método:

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

Y esta es la forma en que puedo usarlo:

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

Estos son algunos métodos de extensión que pueden ayudar

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

Si se trata de validar los parámetros del método, ninguna de las soluciones arroja ArgumentOutOfRangeException y permite una configuración fácil / adecuada de valores min / max inclusivos / exclusivos.

Usar así

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

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

Acabo de escribir estas hermosas funciones. También tiene la ventaja de no tener ramificaciones (un solo if) para valores válidos. La parte más difícil es crear los mensajes de excepción adecuados.

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

Que estas buscando in [1..100]? Eso es solo Pascal.