Tôi có thể tìm thấy chức năng "kẹp" trong .NET ở đâu?

Tôi muốn kẹp một giá trị xvào một phạm vi[a, b] :

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

Điều này khá cơ bản. Nhưng tôi không thấy một hàm "kẹp" trong thư viện lớp - ít nhất là không có trongSystem.Math .

(Đối với người không biết "kẹp" một giá trị là đảm bảo rằng nó nằm giữa một số giá trị lớn nhất và nhỏ nhất. Nếu nó lớn hơn giá trị tối đa, thì nó được thay thế bằng giá trị tối đa, v.v.)

Bạn có thể viết một phương thức mở rộng:

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

Các phương thức mở rộng đi trong các lớp tĩnh - vì đây là một hàm cấp thấp, nên có lẽ nó sẽ nằm trong một số không gian tên cốt lõi trong dự án của bạn. Sau đó, bạn có thể sử dụng phương thức này trong bất kỳ tệp mã nào có chứa chỉ thị using cho không gian tên, ví dụ:

using Core.ExtensionMethods

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

.NET Core 2.0

Bắt đầu với .NET Core 2.0 System.Mathbây giờ có một Clampphương pháp có thể được sử dụng thay thế:

using System;

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

Chỉ cần sử dụng Math.Minvà Math.Max:

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

Thử:

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

Không có một cái, nhưng không quá khó để làm một cái. Tôi tìm thấy một cái ở đây: kẹp

Nó là:

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

Và nó có thể được sử dụng như:

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

Không có một trong System.Mathkhông gian tên .

Có một MathHelperLớp học có sẵn cho studio trò chơi XNA nếu điều đó xảy ra với những gì bạn đang làm:

Chỉ chia sẻ giải pháp của Lee với các vấn đề và mối quan tâm của bình luận được giải quyết, nếu có thể:

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

Sự khác biệt:

• Tên phương thức sử dụng thì động từ thích hợp ( ed) để (thêm nữa) chỉ ra rằng giá trị không được kẹp tại chỗ và thay vào đó, một giá trị mới được trả về (Xem nhận xét của @ JimBalter ).
• Có phù hợp null checktrên tất cả các đầu vào (Xem bình luận của @ JeppeStigNielsen ).
• Hoán đổi minvà maxnếu min > max(Xem bình luận của @ JeppeStigNielsen ).

Hạn chế: Không có kẹp một bên. Nếu maxlà NaN, luôn luôn trả về NaN(Xem comment Herman của ).

Sử dụng các câu trả lời trước, tôi cô đọng nó thành đoạn mã dưới đây cho nhu cầu của tôi. Điều này cũng sẽ cho phép bạn kẹp một số chỉ bằng giá trị nhỏ nhất hoặc tối đa của nó.

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

Đoạn mã dưới đây hỗ trợ chỉ định giới hạn theo bất kỳ thứ tự nào (tức là bound1 <= bound2hoặc bound2 <= bound1). Tôi thấy điều này hữu ích cho các giá trị kẹp được tính toán từ phương trình tuyến tính ( y=mx+b) trong đó độ dốc của đường có thể tăng hoặc giảm.

Tôi biết: Đoạn mã bao gồm năm toán tử biểu thức điều kiện siêu xấu . Vấn đề là, nó hoạt động và các thử nghiệm dưới đây đã chứng minh điều đó. Vui lòng thêm các dấu ngoặc đơn không cần thiết nếu bạn muốn.

Bạn có thể dễ dàng tạo quá tải khác cho các loại số khác và về cơ bản sao chép / dán các bài kiểm tra.

Cảnh báo: So sánh số dấu phẩy động không đơn giản. Mã này không thực hiện doubleso sánh một cách mạnh mẽ. Sử dụng thư viện so sánh dấu phẩy động để thay thế việc sử dụng các toán tử so sánh.

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

Kiểm tra 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);
    }
}

Nếu tôi muốn xác thực phạm vi của một đối số trong [min, max], tôi sử dụng lớp tiện dụng sau:

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

Lớp hoạt động cho tất cả các đối tượng IComparable. Tôi tạo một phiên bản với một phạm vi nhất định:

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

Tôi xác thực một đối số

range.Validate(value);

hoặc kẹp đối số vào phạm vi:

var v = range.Validate(value);