BigInteger.CompareTo 方法

参考

定义

命名空间:: System.Numerics

程序集:: System.Runtime.Numerics.dll

程序集:: System.Numerics.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

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

重载

CompareTo(Int64)	将此实例与 64 位带符号整数进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于 64 位带符号整数的值。
CompareTo(BigInteger)	将此实例与另一个 BigInteger 进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于指定对象的值。
CompareTo(Object)	将此实例与指定对象进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于指定对象的值。
CompareTo(UInt64)	将此实例与 64 位无符号整数进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于 64 位无符号整数的值。

CompareTo(Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将此实例与 64 位带符号整数进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于 64 位带符号整数的值。

public:
 int CompareTo(long other);

public int CompareTo (long other);

member this.CompareTo : int64 -> int

Public Function CompareTo (other As Long) As Integer

参数

other: Int64

要比较的 64 位带符号整数。

Int32

一个带符号整数值，指示此实例与 other 的关系，如下表所示。

返回值	说明
小于零	当前实例小于 `other`。
零	当前实例等于 `other`。
大于零	当前实例大于 `other`。

示例

以下示例演示了使用整型值调用 CompareTo(Int64) 方法的结果。

BigInteger bigIntValue = BigInteger.Parse("3221123045552");

byte byteValue = 16;
sbyte sbyteValue = -16;
short shortValue = 1233;
ushort ushortValue = 1233;
int intValue = -12233;
uint uintValue = 12233;
long longValue = 12382222;
ulong ulongValue = 1238222;

Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, byteValue,
                  bigIntValue.CompareTo(byteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, sbyteValue,
                  bigIntValue.CompareTo(sbyteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, shortValue,
                  bigIntValue.CompareTo(shortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ushortValue,
                  bigIntValue.CompareTo(ushortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, intValue,
                  bigIntValue.CompareTo(intValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, uintValue,
                  bigIntValue.CompareTo(uintValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, longValue,
                  bigIntValue.CompareTo(longValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ulongValue,
                  bigIntValue.CompareTo(ulongValue));
// The example displays the following output:
//       Comparing 3221123045552 with 16: 1
//       Comparing 3221123045552 with -16: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with -12233: 1
//       Comparing 3221123045552 with 12233: 1
//       Comparing 3221123045552 with 12382222: 1
//       Comparing 3221123045552 with 1238222: 1

Dim bigIntValue As BigInteger = BigInteger.Parse("3221123045552")

Dim byteValue As Byte = 16
Dim sbyteValue As SByte = -16
Dim shortValue As Short = 1233      
Dim ushortValue As UShort = 1233
Dim intValue As Integer = -12233
Dim uintValue As UInteger = 12233
Dim longValue As Long = 12382222
Dim ulongValue As Integer = 1238222

Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, byteValue, _
                  bigIntValue.CompareTo(byteValue))
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, sbyteValue, _
                  bigIntValue.CompareTo(sbyteValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, shortValue, _
                  bigIntValue.CompareTo(shortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ushortValue, _
                  bigIntValue.CompareTo(ushortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, intValue, _
                  bigIntValue.CompareTo(intValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, uintValue, _
                  bigIntValue.CompareTo(uintValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, longValue, _
                  bigIntValue.CompareTo(longValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ulongValue, _
                  bigIntValue.CompareTo(ulongValue))
' The example displays the following output:
'       Comparing 3221123045552 with 16: 1
'       Comparing 3221123045552 with -16: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with -12233: 1
'       Comparing 3221123045552 with 12233: 1
'       Comparing 3221123045552 with 12382222: 1
'       Comparing 3221123045552 with 1238222: 1

注解

如果 other 是 Byte、Int16、Int32、SByte、 UInt16或 UInt32 值，则调用方法时CompareTo(Int64)，它将隐式转换为Int64值。

适用于

CompareTo(BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 virtual int CompareTo(System::Numerics::BigInteger other);

public int CompareTo (System.Numerics.BigInteger other);

abstract member CompareTo : System.Numerics.BigInteger -> int
override this.CompareTo : System.Numerics.BigInteger -> int

Public Function CompareTo (other As BigInteger) As Integer

参数

other: BigInteger

要比较的对象。

Int32

一个带符号整数值，指示此实例与 other 的关系，如下表所示。

返回值	说明
小于零	当前实例小于 `other`。
零	当前实例等于 `other`。
大于零	当前实例大于 `other`。

实现

CompareTo(T)

示例

下面的示例演示如何使用 CompareTo(BigInteger) 方法对对象列表 StarInfo 进行排序。每个物体都 StarInfo 提供有关恒星名称及其与地球距离的信息（以英里为单位）。 StarInfo 实现 IComparable<T> 接口，该接口允许 StarInfo 按泛型集合类对对象进行排序。它的 IComparable<T>.CompareTo 实现只是包装对的 CompareTo(BigInteger)调用。

using System;
using System.Collections.Generic;
using System.Numerics;

public struct StarInfo : IComparable<StarInfo>
{
   // Define constructors.
   public StarInfo(string name, double lightYears)
   {
      this.Name = name;

      // Calculate distance in miles from light years.
      this.Distance = (BigInteger) Math.Round(lightYears * 5.88e12);
   }

   public StarInfo(string name, BigInteger distance)
   {
      this.Name = name;
      this.Distance = distance;
   }

   // Define public fields.
   public string Name;
   public BigInteger Distance;

   // Display name of star and its distance in parentheses.
   public override string ToString()
   {
      return String.Format("{0,-10} ({1:N0})", this.Name, this.Distance);
   }

   // Compare StarInfo objects by their distance from Earth.
   public int CompareTo(StarInfo other)
   {
      return this.Distance.CompareTo(other.Distance);
   }
}

Imports System.Collections.Generic
Imports System.Numerics

Public Structure StarInfo : Implements IComparable(Of StarInfo)
   ' Define constructors.
   Public Sub New(name As String, lightYears As Double)
      Me.Name = name
      ' Calculate distance in miles from light years.
      Me.Distance = CType(Math.Round(lightYears * 5.88e12), BigInteger)
   End Sub
   
   Public Sub New(name As String, distance As BigInteger)
      Me.Name = name
      Me.Distance = distance
   End Sub
   
   ' Define public fields.
   Public Name As String
   Public Distance As BigInteger

   ' Display name of star and its distance in parentheses.
   Public Overrides Function ToString() As String
      Return String.Format("{0,-10} ({1:N0})", Me.Name, Me.Distance)
   End Function

   ' Compare StarInfo objects by their distance from Earth.
   Public Function CompareTo(other As starInfo) As Integer _
                   Implements IComparable(Of StarInfo).CompareTo
      Return Me.Distance.CompareTo(other.Distance)
   End Function                
End Structure

然后，以下代码实例化四 StarInfo 个对象，并将其存储在泛型 List<T> 对象中。 List<T>.Sort调用方法后，StarInfo对象将按其与地球的距离顺序显示。

public class Example
{
   public static void Main()
   {
      StarInfo star;
      List<StarInfo> stars = new List<StarInfo>();

      star = new StarInfo("Sirius", 8.6d);
      stars.Add(star);
      star = new StarInfo("Rigel", 1400d);
      stars.Add(star);
      star = new StarInfo("Castor", 49d);
      stars.Add(star);
      star = new StarInfo("Antares", 520d);
      stars.Add(star);

      stars.Sort();

      foreach (StarInfo sortedStar in stars)
         Console.WriteLine(sortedStar);
   }
}
// The example displays the following output:
//       Sirius     (50,568,000,000,000)
//       Castor     (288,120,000,000,000)
//       Antares    (3,057,600,000,000,000)
//       Rigel      (8,232,000,000,000,000)

Module Example
   Public Sub Main()
      Dim star As StarInfo
      Dim stars As New List(Of StarInfo)
      
      star = New StarInfo("Sirius", 8.6d)
      stars.Add(star)
      star = New StarInfo("Rigel", 1400d)
      stars.Add(star)
      star = New StarInfo("Castor", 49d)
      stars.Add(star)
      star = New StarInfo("Antares", 520d)
      stars.Add(star)
      
      stars.Sort()
      
      For Each star In stars
         Console.WriteLine(star)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Sirius     (50,568,000,000,000)
'       Castor     (288,120,000,000,000)
'       Antares    (3,057,600,000,000,000)
'       Rigel      (8,232,000,000,000,000)

注解

方法的 CompareTo 此重载实现 IComparable<T>.CompareTo 方法。泛型集合对象使用它对集合中的项进行排序。

另请参阅

适用于

CompareTo(Object)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 virtual int CompareTo(System::Object ^ obj);

public int CompareTo (object? obj);

public int CompareTo (object obj);

abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int

Public Function CompareTo (obj As Object) As Integer

参数

obj: Object

要比较的对象。

Int32

一个带符号整数，指示当前实例与 obj 参数的关系，如下表所示。

返回值	说明
小于零	当前实例小于 `obj`。
零	当前实例等于 `obj`。
大于零	当前实例大于 `obj`，或者 `obj` 参数为 `null`。

实现

CompareTo(Object)

例外

ArgumentException

obj 不是 BigInteger。

示例

以下示例调用方法， CompareTo(Object) 将值与对象数组中的每个元素进行比较 BigInteger ：

object[] values = { BigInteger.Pow(Int64.MaxValue, 10), null,
                    12.534, Int64.MaxValue, BigInteger.One };
BigInteger number = UInt64.MaxValue;

foreach (object value in values)
{
   try {
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value,
                        number.CompareTo(value));
   }
   catch (ArgumentException) {
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
//    Comparing 18446744073709551615 with '': 1
//    Unable to compare the Double value 12.534 with a BigInteger.
//    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
//    Comparing 18446744073709551615 with '1': 1

Dim values() As Object = { BigInteger.Pow(Int64.MaxValue, 10), Nothing, 
                           12.534, Int64.MaxValue, BigInteger.One }
Dim number As BigInteger = UInt64.MaxValue

For Each value As Object In values
   Try
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value, 
                        number.CompareTo(value))
   Catch e As ArgumentException
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value)
   End Try                     
Next                                 
' The example displays the following output:
'    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
'    Comparing 18446744073709551615 with '': 1
'    Unable to compare the Double value 12.534 with a BigInteger.
'    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
'    Comparing 18446744073709551615 with '1': 1

注解

方法的 CompareTo 此重载实现 IComparable.CompareTo 方法。非泛型集合对象使用它对集合中的项进行排序。

参数 obj 必须是下列值之一：

运行时类型为 BigInteger的对象。
值为 Object 的 null变量。如果参数null的obj值为，则该方法返回 1，指示当前实例大于 obj。

另请参阅

IComparable

适用于

CompareTo(UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

将此实例与 64 位无符号整数进行比较，并返回一个整数，该整数指示此实例的值是小于、等于还是大于 64 位无符号整数的值。

public:
 int CompareTo(System::UInt64 other);

[System.CLSCompliant(false)]
public int CompareTo (ulong other);

[<System.CLSCompliant(false)>]
member this.CompareTo : uint64 -> int

Public Function CompareTo (other As ULong) As Integer

参数

other: UInt64

要比较的 64 位无符号整数。

Int32

一个带符号整数，指示此实例和 other 的相对值，如下表所示。

返回值	说明
小于零	当前实例小于 `other`。
零	当前实例等于 `other`。
大于零	当前实例大于 `other`。

属性: CLSCompliantAttribute

适用于

BigInteger.CompareTo 方法

定义

重载

CompareTo(Int64)

参数

返回

示例

注解

适用于

CompareTo(BigInteger)

参数

返回

实现

示例

注解

另请参阅

适用于

CompareTo(Object)

参数

返回

实现

例外

示例

注解

另请参阅

适用于

CompareTo(UInt64)

参数

返回

适用于

反馈

其他资源