Question

我厌倦了写x > min && x < max所以我想写一个简单的函数，但我不确定我是否做得对...实际上我不是因为我得到了一个错误：

    bool inBetween<T>(T x, T min, T max) where T:IComparable
    {
        return (x > min && x < max);
    }

错误：

Operator '>' cannot be applied to operands of type 'T' and 'T'
Operator '<' cannot be applied to operands of type 'T' and 'T'

我可能对函数声明中的where部分了解不足

注意：对于那些打算告诉我我将编写比以前更多代码的人...考虑可读性=）任何帮助将不胜感激

修改

已删除，因为已解决=）

另一个编辑

所以经过一番头痛之后，我在@Jay极端可读性的想法之后出现了这个（嗯）的事情：

public static class test
{
    public static comparision Between<T>(this T a,T b) where T : IComparable
    {
        var ttt = new comparision();
        ttt.init(a);
        ttt.result = a.CompareTo(b) > 0;
        return ttt;
    }

    public static bool And<T>(this comparision state, T c) where T : IComparable
    {
        return state.a.CompareTo(c) < 0 && state.result;
    }

    public class comparision
    {
        public IComparable a;
        public bool result;          
        public void init<T>(T ia) where T : IComparable
        {
            a = ia;
        }

    }
}

现在你可以比较任何具有极高可读性的东西=）

你怎么想...我不是表演大师，所以欢迎任何调整

Answer 1

IComparable表示该对象实现了CompareTo方法。使用

public static bool InBetween<T>(this T x, T min, T max) where T:IComparable<T>
{
    return x.CompareTo(min) > 0 && x.CompareTo(max) < 0;
}

Answer 2

您需要使用变量的.CompareTo方法并检查＆lt;和＆gt; 0.（这就是你将T限制为IComparable的原因。）

return (x.CompareTo(min) > 0 && x.CompareTo(max) < 0);

Answer 3

return x.CompareTo(min) > 0 && x.CompareTo(max) < 0;

如果您希望获得最大可读性，可以在IComparable<T>上使用扩展方法，并创建如下语法：

return 5.IsBetween(10).and(20);

或

return 5.IsBetween(10.and(20));

以下是第二个示例的实现：

public interface IRange<T>
{
    bool ContainsInclusive(T value);
    bool ContainsExclusive(T value);
}

public class ComparableRange<T> : IRange<T> where T : IComparable<T>
{
    T min;
    T max;

    public ComparableRange(T min, T max)
    {
        this.min = min;
        this.max = max;
    }

    public bool ContainsInclusive(T value)
    {
        return value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0;
    }

    public bool ContainsExclusive(T value)
    {
        return value.CompareTo(min) > 0 && value.CompareTo(max) < 0;
    }
}

public static class ComparableExtensions
{
    public static IRange<T> and<T>(this T min, T max) where T : IComparable<T>
    {
        return new ComparableRange<T>(min, max);
    }

    public static bool IsBetween<T>(this T value, IRange<T> range) where T : IComparable<T>
    {
        return range.ContainsExclusive(value);
    }
}

Answer 4

使用IComparable.CompareTo()：

a.CompareTo（b）＆gt; 0＆lt; =＆gt;一个＆GT，B

a.CompareTo（b）= 0＆lt; =＆gt; A = B

a.CompareTo（b）＆lt; 0＆lt; =＆gt;一个＆LT，B

public bool InBetween<T>(T x, T min, T max) where T:IComparable
{
    return x.CompareTo(min) * x.CompareTo(max) < 0;
}

Answer 5

您可以尝试添加T是IComparable的约束，然后使用CompareTo而不是＆lt;和＆gt;。

但这可能不会让您发送您可能想要的所有值类型。在这种情况下，只需创建所需的重载，无需泛型。

通用的InBetween函数

5 个答案: