¿Dónde puedo encontrar la función "sujetar" en .NET?

Me gustaría fijar un valor xa un rango [a, b]:

x = (x < a) ? a : ((x > b) ? b : x);

Esto es bastante básico. Pero no veo una función "clamp" en la biblioteca de clases, al menos no en System.Math.

(Para los que no lo saben, "sujetar" un valor es asegurarse de que se encuentra entre algunos valores máximos y mínimos. Si es mayor que el valor máximo, entonces se reemplaza por el máximo, etc.)

Podrías escribir un método de extensión:

public static T Clamp<T>(this T val, T min, T max) where T : IComparable<T>
{
    if (val.CompareTo(min) < 0) return min;
    else if(val.CompareTo(max) > 0) return max;
    else return val;
}

Los métodos de extensión van en clases estáticas; dado que esta es una función de nivel bastante bajo, probablemente debería ir en algún espacio de nombres central en su proyecto. Luego puede usar el método en cualquier archivo de código que contenga una directiva using para el espacio de nombres, por ejemplo

using Core.ExtensionMethods

int i = 4.Clamp(1, 3);

.NET Core 2.0

Comenzando con .NET Core 2.0 System.Mathahora tiene un Clampmétodo que se puede usar en su lugar:

using System;

int i = Math.Clamp(4, 1, 3);

Solo usa Math.Miny Math.Max:

x = Math.Min(Math.Max(x, a), b);

Tratar:

public static int Clamp(int value, int min, int max)  
{  
    return (value < min) ? min : (value > max) ? max : value;  
}

No hay uno, pero no es demasiado difícil hacer uno. Encontré uno aquí: abrazadera

Es:

public static T Clamp<T>(T value, T max, T min)
    where T : System.IComparable<T> {
        T result = value;
        if (value.CompareTo(max) > 0)
            result = max;
        if (value.CompareTo(min) < 0)
            result = min;
        return result;
    }

Y se puede usar como:

int i = Clamp(12, 10, 0); -> i == 10
double d = Clamp(4.5, 10.0, 0.0); -> d == 4.5

No hay uno en el System.Mathespacio de nombres .

Hay una MathHelperclase en la que está disponible para el estudio de juegos XNA si eso es lo que estás haciendo:

Simplemente compartiendo la solución de Lee con los problemas e inquietudes de los comentarios abordados, cuando sea posible:

public static T Clamped<T>(this T value, T min, T max) where T : IComparable<T> {
    if (value == null) throw new ArgumentNullException(nameof(value), "is null.");
    if (min == null) throw new ArgumentNullException(nameof(min), "is null.");
    if (max == null) throw new ArgumentNullException(nameof(max), "is null.");
    //If min <= max, clamp
    if (min.CompareTo(max) <= 0) return value.CompareTo(min) < 0 ? min : value.CompareTo(max) > 0 ? max : value;
    //If min > max, clamp on swapped min and max
    return value.CompareTo(max) < 0 ? max : value.CompareTo(min) > 0 ? min : value;
}

Diferencias:

• El nombre del método usa el tiempo verbal apropiado ( ed) para (más) indicar que el valor no se fija en el lugar y que, en cambio, se devuelve un nuevo valor (ver el comentario de @ JimBalter ).
• Es apropiado null checken todas las entradas (ver el comentario de @ JeppeStigNielsen ).
• Swaps miny maxif min > max(ver el comentario de @ JeppeStigNielsen ).

Limitaciones: No se permiten abrazaderas unilaterales. Si maxes NaN, siempre regresa NaN(Ver comentario de Herman ).

Usando las respuestas anteriores, lo condensé en el siguiente código para mis necesidades. Esto también le permitirá fijar un número solo por su mínimo o máximo.

public static class IComparableExtensions
{
    public static T Clamped<T>(this T value, T min, T max) 
        where T : IComparable<T>
    {
        return value.CompareTo(min) < 0 ? min : value.ClampedMaximum(max);
    }

    public static T ClampedMinimum<T>(this T value, T min)
        where T : IComparable<T>
    {
        return value.CompareTo(min) < 0 ? min : value;
    }

    public static T ClampedMaximum<T>(this T value, T max)
        where T : IComparable<T>
    {
        return value.CompareTo(max) > 0 ? max : value;
    }
}

El siguiente código admite la especificación de límites en cualquier orden (es decir bound1 <= bound2, o bound2 <= bound1). Encontré esto útil para fijar valores calculados a partir de ecuaciones lineales ( y=mx+b) donde la pendiente de la línea puede aumentar o disminuir.

Lo sé: el código consta de cinco operadores de expresión condicional súper feos . La cosa es que funciona , y las pruebas a continuación lo demuestran. No dude en agregar paréntesis estrictamente innecesarios si así lo desea.

Puede crear fácilmente otras sobrecargas para otros tipos numéricos y básicamente copiar / pegar las pruebas.

Advertencia: comparar números de punto flotante no es sencillo. Este código no implementa doublecomparaciones de manera sólida. Utilice una biblioteca de comparación de punto flotante para reemplazar los usos de los operadores de comparación.

public static class MathExtensions
{
    public static double Clamp(this double value, double bound1, double bound2)
    {
        return bound1 <= bound2 ? value <= bound1 ? bound1 : value >= bound2 ? bound2 : value : value <= bound2 ? bound2 : value >= bound1 ? bound1 : value;
    }
}

Pruebas de xUnit / FluentAssertions:

public class MathExtensionsTests
{
    [Theory]
    [InlineData(0, 0, 0, 0)]
    [InlineData(0, 0, 2, 0)]
    [InlineData(-1, 0, 2, 0)]
    [InlineData(1, 0, 2, 1)]
    [InlineData(2, 0, 2, 2)]
    [InlineData(3, 0, 2, 2)]
    [InlineData(0, 2, 0, 0)]
    [InlineData(-1, 2, 0, 0)]
    [InlineData(1, 2, 0, 1)]
    [InlineData(2, 2, 0, 2)]
    [InlineData(3, 2, 0, 2)]
    public void MustClamp(double value, double bound1, double bound2, double expectedValue)
    {
        value.Clamp(bound1, bound2).Should().Be(expectedValue);
    }
}

Si quiero validar el rango de un argumento en [min, max], uso la siguiente clase útil:

public class RangeLimit<T> where T : IComparable<T>
{
    public T Min { get; }
    public T Max { get; }
    public RangeLimit(T min, T max)
    {
        if (min.CompareTo(max) > 0)
            throw new InvalidOperationException("invalid range");
        Min = min;
        Max = max;
    }

    public void Validate(T param)
    {
        if (param.CompareTo(Min) < 0 || param.CompareTo(Max) > 0)
            throw new InvalidOperationException("invalid argument");
    }

    public T Clamp(T param) => param.CompareTo(Min) < 0 ? Min : param.CompareTo(Max) > 0 ? Max : param;
}

La clase funciona para todos los objetos que son IComparable. Creo una instancia con un cierto rango:

RangeLimit<int> range = new RangeLimit<int>(0, 100);

Yo valido un argumento

range.Validate(value);

o sujete el argumento al rango:

var v = range.Validate(value);