语言

Double.CompareTo 方法

定义

将此实例与指定的对象或 Double 对象进行比较,并返回一个整数,该值指示此实例的值是小于、等于还是大于指定对象或 Double 对象的值。

重载

名称 说明
CompareTo(Double)

将此实例与指定的双精度浮点数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定的双精度浮点数的值。

CompareTo(Object)

将此实例与指定的对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。

CompareTo(Double)

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

将此实例与指定的双精度浮点数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定的双精度浮点数的值。

public:
 virtual int CompareTo(double value);
public int CompareTo(double value);
abstract member CompareTo : double -> int
override this.CompareTo : double -> int
Public Function CompareTo (value As Double) As Integer

参数

value
Double

要比较的双精度浮点数。

返回

一个有符号数字,指示此实例的相对值和 value。

返回值 说明
小于零 此实例小于 value,或者此实例不是数字(NaN)且 value 为数字。
零 此实例等于 value,或同时等于此实例, value 而不是数字 (NaN), PositiveInfinity或 NegativeInfinity。
大于零 此实例大于 value,或者此实例是一个数字, value 而不是一个数字(NaN)。

实现

示例

下面的代码示例演示了多个值和引用类型的方法的 CompareTo 泛型和非泛型版本。

// This example demonstrates the generic and non-generic versions of the
// CompareTo method for several base types.
// The non-generic version takes a parameter of type Object, while the generic
// version takes a type-specific parameter, such as Boolean, Int32, or Double.

using System;

class Sample
{
    public static void Main()
    {
    string    nl = Environment.NewLine;
    string    msg = "{0}The following is the result of using the generic and non-generic{0}" +
                    "versions of the CompareTo method for several base types:{0}";

    DateTime  now = DateTime.Now;
// Time span = 11 days, 22 hours, 33 minutes, 44 seconds
    TimeSpan  tsX = new TimeSpan(11, 22, 33, 44);
// Version = 1.2.333.4
    Version   versX = new Version("1.2.333.4");
// Guid = CA761232-ED42-11CE-BACD-00AA0057B223
    Guid      guidX = new Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}");

    Boolean  a1 = true,  a2 = true;
    Byte     b1 = 1,     b2 = 1;
    Int16    c1 = -2,    c2 = 2;
    Int32    d1 = 3,     d2 = 3;
    Int64    e1 = 4,     e2 = -4;
    Decimal  f1 = -5.5m, f2 = 5.5m;
    Single   g1 = 6.6f,  g2 = 6.6f;
    Double   h1 = 7.7d,  h2 = -7.7d;
    Char     i1 = 'A',   i2 = 'A';
    String   j1 = "abc", j2 = "abc";
    DateTime k1 = now,   k2 = now;
    TimeSpan l1 = tsX,   l2 = tsX;
    Version  m1 = versX, m2 = new Version("2.0");
    Guid     n1 = guidX, n2 = guidX;

// The following types are not CLS-compliant.
    SByte    w1 = 8,     w2 = 8;
    UInt16   x1 = 9,     x2 = 9;
    UInt32   y1 = 10,    y2 = 10;
    UInt64   z1 = 11,    z2 = 11;
//
    Console.WriteLine(msg, nl);
    try
        {
// The second and third Show method call parameters are automatically boxed because
// the second and third Show method declaration arguments expect type Object.

        Show("Boolean:  ", a1, a2, a1.CompareTo(a2), a1.CompareTo((Object)a2));
        Show("Byte:     ", b1, b2, b1.CompareTo(b2), b1.CompareTo((Object)b2));
        Show("Int16:    ", c1, c2, c1.CompareTo(c2), c1.CompareTo((Object)c2));
        Show("Int32:    ", d1, d2, d1.CompareTo(d2), d1.CompareTo((Object)d2));
        Show("Int64:    ", e1, e2, e1.CompareTo(e2), e1.CompareTo((Object)e2));
        Show("Decimal:  ", f1, f2, f1.CompareTo(f2), f1.CompareTo((Object)f2));
        Show("Single:   ", g1, g2, g1.CompareTo(g2), g1.CompareTo((Object)g2));
        Show("Double:   ", h1, h2, h1.CompareTo(h2), h1.CompareTo((Object)h2));
        Show("Char:     ", i1, i2, i1.CompareTo(i2), i1.CompareTo((Object)i2));
        Show("String:   ", j1, j2, j1.CompareTo(j2), j1.CompareTo((Object)j2));
        Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo((Object)k2));
        Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo((Object)l2));
        Show("Version:  ", m1, m2, m1.CompareTo(m2), m1.CompareTo((Object)m2));
        Show("Guid:     ", n1, n2, n1.CompareTo(n2), n1.CompareTo((Object)n2));
//
        Console.WriteLine("{0}The following types are not CLS-compliant:", nl);
        Show("SByte:    ", w1, w2, w1.CompareTo(w2), w1.CompareTo((Object)w2));
        Show("UInt16:   ", x1, x2, x1.CompareTo(x2), x1.CompareTo((Object)x2));
        Show("UInt32:   ", y1, y2, y1.CompareTo(y2), y1.CompareTo((Object)y2));
        Show("UInt64:   ", z1, z2, z1.CompareTo(z2), z1.CompareTo((Object)z2));
        }
    catch (Exception e)
        {
        Console.WriteLine(e);
        }
    }

    public static void Show(string caption, Object var1, Object var2,
                            int resultGeneric, int resultNonGeneric)
    {
    string relation;

    Console.Write(caption);
    if (resultGeneric == resultNonGeneric)
        {
        if      (resultGeneric < 0) relation = "less than";
        else if (resultGeneric > 0) relation = "greater than";
        else                        relation = "equal to";
        Console.WriteLine("{0} is {1} {2}", var1, relation, var2);
        }

// The following condition will never occur because the generic and non-generic
// CompareTo methods are equivalent.

    else
        {
        Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}",
                           resultGeneric, resultNonGeneric);
        }
   }
}
/*
This example produces the following results:

The following is the result of using the generic and non-generic versions of the
CompareTo method for several base types:

Boolean:  True is equal to True
Byte:     1 is equal to 1
Int16:    -2 is less than 2
Int32:    3 is equal to 3
Int64:    4 is greater than -4
Decimal:  -5.5 is less than 5.5
Single:   6.6 is equal to 6.6
Double:   7.7 is greater than -7.7
Char:     A is equal to A
String:   abc is equal to abc
DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
TimeSpan: 11.22:33:44 is equal to 11.22:33:44
Version:  1.2.333.4 is less than 2.0
Guid:     ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
aa0057b223

The following types are not CLS-compliant:
SByte:    8 is equal to 8
UInt16:   9 is equal to 9
UInt32:   10 is equal to 10
UInt64:   11 is equal to 11
*/
' This example demonstrates the generic and non-generic versions of the 
' CompareTo method for several base types.
' The non-generic version takes a parameter of type Object, while the generic
' version takes a type-specific parameter, such as Boolean, Int32, or Double.

Class Sample
   Public Shared Sub Main()
      Dim nl As String = Environment.NewLine
      Dim msg As String = _
          "{0}The following is the result of using the generic and non-generic{0}" & _
          "versions of the CompareTo method for several base types:{0}"
      
      Dim now As DateTime = DateTime.Now
      ' Time span = 11 days, 22 hours, 33 minutes, 44 seconds
      Dim tsX As New TimeSpan(11, 22, 33, 44)
      ' Version = 1.2.333.4
      Dim versX As New Version("1.2.333.4")
      ' Guid = CA761232-ED42-11CE-BACD-00AA0057B223
      Dim guidX As New Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}")
      
      Dim a1 As [Boolean] = True,    a2 As [Boolean] = True
      Dim b1 As [Byte] = 1,          b2 As [Byte] = 1
      Dim c1 As Int16 = -2,          c2 As Int16 = 2
      Dim d1 As Int32 = 3,           d2 As Int32 = 3
      Dim e1 As Int64 = 4,           e2 As Int64 = -4
      Dim f1 As [Decimal] = -5.5D,   f2 As [Decimal] = 5.5D
      Dim g1 As [Single] = 6.6F,     g2 As [Single] = 6.6F
      Dim h1 As [Double] = 7.7,      h2 As [Double] = -7.7
      Dim i1 As [Char] = "A"c,       i2 As [Char] = "A"c
      Dim j1 As String = "abc",      j2 As String = "abc"
      Dim k1 As DateTime = now,      k2 As DateTime = now
      Dim l1 As TimeSpan = tsX,      l2 As TimeSpan = tsX
      Dim m1 As Version = versX,     m2 As New Version("2.0")
      Dim n1 As Guid = guidX,        n2 As Guid = guidX
      
      ' The following types are not CLS-compliant.
      ' SByte, UInt16, UInt32, UInt64

      Console.WriteLine(msg, nl)
      Try
         ' The second and third Show method call parameters are automatically boxed because
         ' the second and third Show method declaration arguments expect type Object.

         Show("Boolean:  ", a1, a2, a1.CompareTo(a2), a1.CompareTo(CObj(a2)))
         Show("Byte:     ", b1, b2, b1.CompareTo(b2), b1.CompareTo(CObj(b2)))
         Show("Int16:    ", c1, c2, c1.CompareTo(c2), c1.CompareTo(CObj(c2)))
         Show("Int32:    ", d1, d2, d1.CompareTo(d2), d1.CompareTo(CObj(d2)))
         Show("Int64:    ", e1, e2, e1.CompareTo(e2), e1.CompareTo(CObj(e2)))
         Show("Decimal:  ", f1, f2, f1.CompareTo(f2), f1.CompareTo(CObj(f2)))
         Show("Single:   ", g1, g2, g1.CompareTo(g2), g1.CompareTo(CObj(g2)))
         Show("Double:   ", h1, h2, h1.CompareTo(h2), h1.CompareTo(CObj(h2)))
         Show("Char:     ", i1, i2, i1.CompareTo(i2), i1.CompareTo(CObj(i2)))
         Show("String:   ", j1, j2, j1.CompareTo(j2), j1.CompareTo(CObj(j2)))
         Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo(CObj(k2)))
         Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo(CObj(l2)))
         Show("Version:  ", m1, m2, m1.CompareTo(m2), m1.CompareTo(CObj(m2)))
         Show("Guid:     ", n1, n2, n1.CompareTo(n2), n1.CompareTo(CObj(n2)))
         '
         Console.WriteLine("{0}The following types are not CLS-compliant:", nl)
         Console.WriteLine("SByte, UInt16, UInt32, UInt64")

      Catch e As Exception
         Console.WriteLine(e)
      End Try
   End Sub
   
   Public Shared Sub Show(caption As String, var1 As [Object], var2 As [Object], _
                          resultGeneric As Integer, resultNonGeneric As Integer)
      Dim relation As String
      
      Console.Write(caption)
      If resultGeneric = resultNonGeneric Then
         If resultGeneric < 0 Then
            relation = "less than"
         ElseIf resultGeneric > 0 Then
            relation = "greater than"
         Else
            relation = "equal to"
         End If
         Console.WriteLine("{0} is {1} {2}", var1, relation, var2)
      
      ' The following condition will never occur because the generic and non-generic
      ' CompareTo methods are equivalent.

      Else
         Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}", _
                            resultGeneric, resultNonGeneric)
      End If
   End Sub
End Class
'
'This example produces the following results:
'
'The following is the result of using the generic and non-generic versions of the
'CompareTo method for several base types:
'
'Boolean:  True is equal to True
'Byte:     1 is equal to 1
'Int16:    -2 is less than 2
'Int32:    3 is equal to 3
'Int64:    4 is greater than -4
'Decimal:  -5.5 is less than 5.5
'Single:   6.6 is equal to 6.6
'Double:   7.7 is greater than -7.7
'Char:     A is equal to A
'String:   abc is equal to abc
'DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
'TimeSpan: 11.22:33:44 is equal to 11.22:33:44
'Version:  1.2.333.4 is less than 2.0
'Guid:     ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
'aa0057b223
'
'The following types are not CLS-compliant:
'SByte, UInt16, UInt32, UInt64
'

注解

CompareTo(Double) 方法

值必须相同,才能被视为相等。 特别是当浮点值依赖于多个数学运算时,它们通常会失去精度,并且它们的值几乎完全相同,但最小有效位数除外。 因此,有时方法的 CompareTo 返回值似乎令人吃惊。 例如,先乘以一个特定的值,再除以相同的值,应得到原始值。 但是,在下面的示例中,计算值原来大于原始值。 使用“R” 标准数字格式字符串 显示这两个值的所有有效数字表示计算值与其最小有效位数中的原始值不同。 有关处理此类比较的信息,请参阅方法的 Equals(Double) “备注”部分。

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
let value1 = 6.185
let value2 = value1 * 0.1 / 0.1
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
Module Example
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Double = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

此方法实现了System.IComparable<T>接口,并且由于不必将Double.CompareTo参数转换为对象,因此比value方法性能稍好。

请注意,尽管值 NaN 不等于另一个值为 NaN (偶数本身)的对象,但 IComparable<T> 接口需要 A.CompareTo(A) 返回零。

CompareTo(Object) 方法

参数 value 必须是 null 或实例 Double;否则,将引发异常。 无论其值如何,任何实例 Double都被视为大于 null。

值必须相同,才能被视为相等。 特别是当浮点值依赖于多个数学运算时,它们通常会失去精度,并且它们的值几乎完全相同,但最小有效位数除外。 因此,有时方法的 CompareTo 返回值似乎令人吃惊。 例如,先乘以一个特定的值,再除以相同的值,应得到原始值。 但是,在下面的示例中,计算值原来大于原始值。 使用“R” 标准数字格式字符串 显示这两个值的所有有效数字表示计算值与其最小有效位数中的原始值不同。 有关处理此类比较的信息,请参阅方法的 Equals(Double) “备注”部分。

using System;

public class Example3
{
    public static void Main()
    {
        double value1 = 6.185;
        object value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
let value1 = 6.185
let value2 = value1 * 0.1 / 0.1 |> box
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
Module Example2
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Object = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

此方法实现以支持 IComparable 接口。 请注意,虽然 NaN 不被视为与另一个 NaN(甚至是其自身)相等,但 IComparable 接口要求 A.CompareTo(A) 返回零。

扩大转换

根据编程语言的不同,可能编码一个CompareTo方法,其中参数类型的比特数少于实例类型(即较窄)。 这是可能的,因为一些编程语言执行隐式扩大转换,该转换将参数表示为一个类型,其位数与实例数相同。

例如,假设实例类型为 Double ,参数类型为 Int32. Microsoft C# 编译器生成将参数值表示为 Double 对象的指令,然后生成一个 Double.CompareTo(Double) 方法,该方法比较实例的值和参数的扩大表示形式。

请参阅编程语言的文档,以确定其编译器是否执行数字类型的隐式扩展转换。 有关详细信息,请参阅 类型转换表 主题。

比较中的精度

超出文档记录精度的浮点数的精度依赖于 .NET 的实现和版本。 因此,两个特定数字的比较可能会在 .NET 的版本之间发生更改,因为数字的内部表示形式的精度可能会更改。

另请参阅

适用于

CompareTo(Object)

Source:
Double.cs
Source:
Double.cs
Source:
Double.cs
Source:
Double.cs
Source:
Double.cs

将此实例与指定的对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。

public:
 virtual int CompareTo(System::Object ^ value);
public int CompareTo(object? value);
public int CompareTo(object value);
abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int
Public Function CompareTo (value As Object) As Integer

参数

value
Object

要比较的对象,或 null。

返回

一个有符号数字,指示此实例的相对值和 value。

值 说明
负整数 此实例小于 value,或者此实例不是数字(NaN)且 value 为数字。
零 此实例等于 value或此实例,并且 value 是两者 Double.NaN, PositiveInfinity或 NegativeInfinity
正整数 此实例大于 value,或者此实例是一个数字, value 而不是一个数字(NaN),OR value 为 null。

实现

例外

value不是 .Double

示例

下面的代码示例演示了在上下文CompareTo中的用法Double。

obj1 = (Double)450;
      
if (a.CompareTo(obj1) < 0)
   Console.WriteLine("{0} is less than {1}.", a.ToString(), obj1.ToString());

if (a.CompareTo(obj1) > 0)
   Console.WriteLine("{0} is greater than {1}.", a.ToString(), obj1.ToString());

if (a.CompareTo(obj1) == 0)
   Console.WriteLine("{0} equals {1}.", a.ToString(), obj1.ToString());
let obj1 = double 450 |> box
    
if a.CompareTo obj1 < 0 then
    printfn $"{a} is less than {obj1}."

if a.CompareTo obj1 > 0 then
    printfn $"{a} is greater than {obj1}."

if a.CompareTo obj1 = 0 then
    printfn $"{a} equals {obj1}."
Obj1 = CType(450, Double)

If A.CompareTo(Obj1) < 0 Then
    Console.WriteLine(A.ToString() + " is less than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) > 0) Then
    Console.WriteLine(A.ToString() + " is greater than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) = 0) Then
    Console.WriteLine(A.ToString() + " equals " + Obj1.ToString() + ".")
End If

注解

CompareTo(Double) 方法

值必须相同,才能被视为相等。 特别是当浮点值依赖于多个数学运算时,它们通常会失去精度,并且它们的值几乎完全相同,但最小有效位数除外。 因此,有时方法的 CompareTo 返回值似乎令人吃惊。 例如,先乘以一个特定的值,再除以相同的值,应得到原始值。 但是,在下面的示例中,计算值原来大于原始值。 使用“R” 标准数字格式字符串 显示这两个值的所有有效数字表示计算值与其最小有效位数中的原始值不同。 有关处理此类比较的信息,请参阅方法的 Equals(Double) “备注”部分。

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
let value1 = 6.185
let value2 = value1 * 0.1 / 0.1
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
Module Example
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Double = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

此方法实现了System.IComparable<T>接口,并且由于不必将Double.CompareTo参数转换为对象,因此比value方法性能稍好。

请注意,尽管值 NaN 不等于另一个值为 NaN (偶数本身)的对象,但 IComparable<T> 接口需要 A.CompareTo(A) 返回零。

CompareTo(Object) 方法

参数 value 必须是 null 或实例 Double;否则,将引发异常。 无论其值如何,任何实例 Double都被视为大于 null。

值必须相同,才能被视为相等。 特别是当浮点值依赖于多个数学运算时,它们通常会失去精度,并且它们的值几乎完全相同,但最小有效位数除外。 因此,有时方法的 CompareTo 返回值似乎令人吃惊。 例如,先乘以一个特定的值,再除以相同的值,应得到原始值。 但是,在下面的示例中,计算值原来大于原始值。 使用“R” 标准数字格式字符串 显示这两个值的所有有效数字表示计算值与其最小有效位数中的原始值不同。 有关处理此类比较的信息,请参阅方法的 Equals(Double) “备注”部分。

using System;

public class Example3
{
    public static void Main()
    {
        double value1 = 6.185;
        object value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
let value1 = 6.185
let value2 = value1 * 0.1 / 0.1 |> box
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1
Module Example2
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Object = value1 * .1 / .1
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

此方法实现以支持 IComparable 接口。 请注意,虽然 NaN 不被视为与另一个 NaN(甚至是其自身)相等,但 IComparable 接口要求 A.CompareTo(A) 返回零。

扩大转换

根据编程语言的不同,可能编码一个CompareTo方法,其中参数类型的比特数少于实例类型(即较窄)。 这是可能的,因为一些编程语言执行隐式扩大转换,该转换将参数表示为一个类型,其位数与实例数相同。

例如,假设实例类型为 Double ,参数类型为 Int32. Microsoft C# 编译器生成将参数值表示为 Double 对象的指令,然后生成一个 Double.CompareTo(Double) 方法,该方法比较实例的值和参数的扩大表示形式。

请参阅编程语言的文档,以确定其编译器是否执行数字类型的隐式扩展转换。 有关详细信息,请参阅 类型转换表 主题。

比较中的精度

超出文档记录精度的浮点数的精度依赖于 .NET 的实现和版本。 因此,两个特定数字的比较可能会在 .NET 的版本之间发生更改,因为数字的内部表示形式的精度可能会更改。

另请参阅

适用于