C# 比较数字得到不同的结果

我相信有一个简单的解释，但无法得出以下结论：

     const short amount = 30000;
     bool isGreater =
             ComparableExtensions.IsGreaterThan(amount, 29000); //returns true

     bool isGreaterThan2 = 
     amount.IsGreaterThan<short>(29000);//returns false

      public static class ComparableExtensions
      {
            public static bool IsGreaterThan<T>(this T leftValue, T rightValue) 
            where T : struct, IComparable<T>
            {
                var result = leftValue.CompareTo(rightValue) == 1;
                return result;
            }

      }

const short amount=30000；
布尔更大=
可比扩展。大于（金额，29000）//返回true
布尔大于2=
金额大于（29000）//返回false
公共静态类可比扩展
{
公共静态布尔值大于（此T leftValue，T rightValue）
其中T:struct，i可比较
{
var结果=leftValue.CompareTo（rightValue）==1；
返回结果；
}
}

是因为我放了一个“结构”约束吗

有什么解释或建议吗

---

谢谢

不，您使用

leftValue.CompareTo（rightValue）==1时出错了

相反，说
leftValue.CompareTo（rightValue）>0

您所知道的是
CompareTo
如果
leftValue
小于
rightValue
，则返回
<0
，如果
leftValue
等于
rightValue
并且
leftValue
大于
rightValue
。您不仅可以检查是否与
1
相等

此外，您看到两个调用之间行为不同的原因是，在第一种情况下，您调用的
大于
，因为文字常量
29000
将被解释为
Int32
，但是在第二种情况下，您明确地说
short
，因此它将被解释为
Int16
 否，使用
leftValue.CompareTo（rightValue）==1时出错

相反，说
leftValue.CompareTo（rightValue）>0

您所知道的是
CompareTo
如果
leftValue
小于
rightValue
，则返回
<0
，如果
leftValue
等于
rightValue
并且
leftValue
大于
rightValue
。您不仅可以检查是否与
1
相等

此外，您看到两个调用之间行为不同的原因是，在第一种情况下，您调用的
大于
，因为文字常量
29000
将被解释为
Int32
，但是在第二种情况下，您明确地说
short
，因此它将被解释为
Int16
 查看
IComparable
的文档，以及
CompareTo
方法的返回值。它声明，如果
a
，它将返回小于零的值；如果
a==b
，它将返回精确的零；如果
a>b
，它将返回大于零的值。然而，您正在将返回值与
1
进行比较。无法保证此方法将返回
1
。你应该改为：

var result = leftValue.CompareTo(rightValue) > 0;

查看
IComparable
的文档，以及
CompareTo
方法的返回值。它声明，如果
a
，它将返回小于零的值；如果
a==b
，它将返回精确的零；如果
a>b
，它将返回大于零的值。然而，您正在将返回值与
1
进行比较。无法保证此方法将返回
1
。你应该改为：

var result = leftValue.CompareTo(rightValue) > 0;

当前的
short.CompareTo（）
实现如下：

public int CompareTo(short value)
{
    return (int)(this - value);
}

public int CompareTo(int value)
{
    if (this < value)
    {
       return -1;
    }
    if (this > value)
    {
       return 1;
    }
    return 0;
}

而
int.CompareTo（）
实现是这样的：

public int CompareTo(short value)
{
    return (int)(this - value);
}

public int CompareTo(int value)
{
    if (this < value)
    {
       return -1;
    }
    if (this > value)
    {
       return 1;
    }
    return 0;
}

但只是说它必须返回：

0            : if the numbers are equal  
a number < 0 : if the number is lower than the other
a number > 0 : if the number is greater than the other

0:如果数字相等
一个小于0的数字：如果该数字小于另一个
大于0的数字：如果该数字大于另一个数字
当前的
short.CompareTo（）
实现如下：

public int CompareTo(short value)
{
    return (int)(this - value);
}

public int CompareTo(int value)
{
    if (this < value)
    {
       return -1;
    }
    if (this > value)
    {
       return 1;
    }
    return 0;
}

而
int.CompareTo（）
实现是这样的：

public int CompareTo(short value)
{
    return (int)(this - value);
}

public int CompareTo(int value)
{
    if (this < value)
    {
       return -1;
    }
    if (this > value)
    {
       return 1;
    }
    return 0;
}

但只是说它必须返回：

0            : if the numbers are equal  
a number < 0 : if the number is lower than the other
a number > 0 : if the number is greater than the other

0:如果数字相等
一个小于0的数字：如果该数字小于另一个
大于0的数字：如果该数字大于另一个数字
编译器在第一次（静态）调用中推断泛型类型。它使用
Int32
。
Int32.CompareTo
方法返回1表示大于

在第二种情况下，来自
Int16
的调用将
T
强制为
Int16
Int16.CompareTo
返回两个值之间的实际差值*。在
IComparable
（仅要求值大于0）下合法，但差异足以导致调用失败

显式强制执行对
short
的第一个调用也会导致失败

*
不，我不知道为什么Int16是那样实现的。似乎是“因为它可以”（
Byte
的行为相同）-因为您可以进行减法，而不必担心溢出（因为您正在为结果转换为更广泛的类型）。为
Int32
做类似的事情需要做更多的工作，我认为这不值得努力。
编译器在第一次（静态）调用中推断泛型类型。它使用
Int32
。
Int32.CompareTo
方法返回1表示大于

在第二种情况下，来自
Int16
的调用将
T
强制为
Int16
Int16.CompareTo
返回两个值之间的实际差值*。在
IComparable
（仅要求值大于0）下合法，但差异足以导致调用失败

显式强制执行对
short
的第一个调用也会导致失败

*
不，我不知道为什么Int16是那样实现的。似乎是“因为它可以”（
Byte
的行为相同）-因为您可以进行减法，而不必担心溢出（因为您正在为结果转换为更广泛的类型）。为
Int32
做类似的事情需要做更多的工作，我认为这不值得努力。
没错，但是