.NET'te "kelepçe" işlevini nerede bulabilirim?

xBir aralığa bir değer sabitlemek istiyorum [a, b]:

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

Bu oldukça basit. Ama sınıf kitaplığında bir "kelepçe" işlevi görmüyorum - en azından içinde değil System.Math.

(Bir değeri "kenetlemeyi" bilmeyenler için, bazı maksimum ve minimum değerler arasında kaldığından emin olmaktır. Maksimum değerden büyükse, maksimum ile değiştirilir, vb.)

Bir uzatma yöntemi yazabilirsiniz:

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

Uzantı yöntemleri statik sınıflara girer - bu oldukça düşük seviyeli bir işlev olduğundan, muhtemelen projenizdeki bazı çekirdek ad alanlarına girmelidir. Daha sonra yöntemi ad alanı için bir using yönergesi içeren herhangi bir kod dosyasında kullanabilirsiniz.

using Core.ExtensionMethods

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

.NET Core 2.0

NET Core 2.0'dan başlayarak System.Mathartık Clampbunun yerine kullanılabilecek bir yöntem var:

using System;

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

Sadece Math.Minve Math.Max:

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

Deneyin:

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

Bir tane yok ama yapmak o kadar da zor değil. Burada bir tane buldum: kelepçe

Bu:

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

Ve şu şekilde kullanılabilir:

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

Bir yok System.Mathad .

Yaptığınız şey buysa MathHelper, XNA oyun stüdyosu için uygun olduğu bir Sınıf var :

Mümkünse, Lee'nin çözümünü yorumların ele alınan sorunları ve endişeleriyle paylaşmanız yeterli :

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

Farklılıklar:

• Yöntem adı ed, değerin yerinde sabitlenmediğini ve bunun yerine yeni bir değerin döndürüldüğünü belirtmek için uygun fiil zamanını ( ) kullanır (Bkz. @ JimBalter'ın açıklaması ).
• null checkTüm girdilere uygun (Bkz. @ JeppeStigNielsen'in yorumu ).
• Swaps minand maxif min > max(Bkz. @ JeppeStigNielsen'ın yorumu ).

Sınırlamalar: Tek taraflı kelepçe yok. Eğer maxbir NaN, her zaman döndürür NaN(Bkz Herman'ın comment ).

Önceki cevapları kullanarak, ihtiyaçlarım için aşağıdaki koda yoğunlaştırdım. Bu aynı zamanda bir sayıyı yalnızca min veya maks.

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

Aşağıdaki kod, sınırların herhangi bir sırada (yani bound1 <= bound2, veya bound2 <= bound1) belirlenmesini destekler . Bunu y=mx+b, çizginin eğiminin arttığı veya azaldığı doğrusal denklemlerden ( ) hesaplanan kenetleme değerleri için yararlı buldum .

Biliyorum: Kod, beş süper çirkin koşullu ifade operatöründen oluşur . Mesele şu ki, işe yarıyor ve aşağıdaki testler bunu kanıtlıyor. İsterseniz, kesinlikle gereksiz parantezler eklemekten çekinmeyin.

Diğer sayısal türler için başka aşırı yüklemeleri kolayca oluşturabilir ve temel olarak testleri kopyalayabilir / yapıştırabilirsiniz.

Uyarı: Kayan noktalı sayıları karşılaştırmak kolay değildir. Bu kod, doublekarşılaştırmaları sağlam bir şekilde gerçekleştirmez. Karşılaştırma operatörlerinin kullanımlarını değiştirmek için bir kayan nokta karşılaştırma kitaplığı kullanı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;
    }
}

xUnit / FluentAssertions testleri:

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

[Min, max] cinsinden bir argümanın aralığını doğrulamak istersem, aşağıdaki kullanışlı sınıfı kullanırım:

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

Sınıf, olan tüm nesneler için çalışır IComparable. Belirli bir aralığa sahip bir örnek oluşturuyorum:

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

Ya bir argümanı doğrularım

range.Validate(value);

veya argümanı aralığa sabitleyin:

var v = range.Validate(value);