BigInteger.CompareTo Metode

Referensi

Definisi

Ruang nama:: System.Numerics

Rakitan:: System.Runtime.Numerics.dll

Rakitan:: System.Numerics.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Membandingkan nilai instans ini dengan nilai lain dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai lainnya.

Overload

CompareTo(Int64)	Membandingkan instans ini dengan bilangan bulat 64-bit yang ditandatangani dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai bilangan bulat 64-bit yang ditandatangani.
CompareTo(BigInteger)	Membandingkan instans ini dengan detik BigInteger dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai objek yang ditentukan.
CompareTo(Object)	Membandingkan instans ini dengan objek tertentu dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai objek yang ditentukan.
CompareTo(UInt64)	Membandingkan instans ini dengan bilangan bulat 64-bit yang tidak ditandatangani dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai bilangan bulat 64-bit yang tidak ditandatangani.

CompareTo(Int64)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Membandingkan instans ini dengan bilangan bulat 64-bit yang ditandatangani dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai bilangan bulat 64-bit yang ditandatangani.

public:
 int CompareTo(long other);

public int CompareTo (long other);

member this.CompareTo : int64 -> int

Public Function CompareTo (other As Long) As Integer

Parameter

other: Int64

Bilangan bulat 64-bit yang ditandatangani untuk dibandingkan.

Mengembalikan

Int32

Nilai bilangan bulat bertanda tangan yang menunjukkan hubungan instans ini ke other, seperti yang ditunjukkan dalam tabel berikut.

Mengembalikan nilai	Deskripsi
Kurang dari nol	Instans saat ini kurang dari `other`.
Nol	Instans `other`saat ini sama dengan .
Lebih besar dari nol	Instans saat ini lebih besar dari `other`.

Contoh

Contoh berikut mengilustrasikan hasil pemanggilan CompareTo(Int64) metode dengan nilai integral.

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

let bigIntValue = BigInteger.Parse "3221123045552"

let byteValue = 16uy
let sbyteValue = -16y
let shortValue = 1233s
let ushortValue = 1233us
let intValue = -12233
let uintValue = 12233u
let longValue = 12382222L
let ulongValue = 1238222UL

printfn $"Comparing {bigIntValue} with {byteValue}: {bigIntValue.CompareTo byteValue}"
printfn $"Comparing {bigIntValue} with {sbyteValue}: {bigIntValue.CompareTo sbyteValue}"
printfn $"Comparing {bigIntValue} with {shortValue}: {bigIntValue.CompareTo shortValue}"
printfn $"Comparing {bigIntValue} with {ushortValue}: {bigIntValue.CompareTo ushortValue}"
printfn $"Comparing {bigIntValue} with {intValue}: {bigIntValue.CompareTo intValue}"
printfn $"Comparing {bigIntValue} with {uintValue}: {bigIntValue.CompareTo uintValue}"
printfn $"Comparing {bigIntValue} with {longValue}: {bigIntValue.CompareTo longValue}"
printfn $"Comparing {bigIntValue} with {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

Keterangan

Jika other adalah Bytenilai , , Int32 Int16, SByte, UInt16, atau UInt32 , secara implisit dikonversi ke Int64 nilai ketika CompareTo(Int64) metode dipanggil.

Berlaku untuk

CompareTo(BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Membandingkan instans ini dengan detik BigInteger dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai objek yang ditentukan.

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

Parameter

other: BigInteger

Objek yang akan dibandingkan.

Mengembalikan

Int32

Nilai bilangan bulat bertanda tangan yang menunjukkan hubungan instans ini ke other, seperti yang ditunjukkan dalam tabel berikut.

Mengembalikan nilai	Deskripsi
Kurang dari nol	Instans saat ini kurang dari `other`.
Nol	Instans `other`saat ini sama dengan .
Lebih besar dari nol	Instans saat ini lebih besar dari `other`.

Penerapan

CompareTo(T)

Contoh

Contoh berikut mengilustrasikan penggunaan CompareTo(BigInteger) metode untuk memesan daftar StarInfo objek. Setiap StarInfo objek memberikan informasi tentang nama star dan jaraknya dari Bumi dalam mil. StarInfo IComparable<T> mengimplementasikan antarmuka, yang memungkinkan StarInfo objek diurutkan berdasarkan kelas koleksi generik. Implementasinya IComparable<T>.CompareTo hanya membungkus panggilan ke 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);
   }
}

open System
open System.Numerics

[<Struct; CustomComparison; StructuralEquality>]
type StarInfo =
    // Define fields
    val Name: string
    val Distance: BigInteger

    // Define constructors.
    new(name, lightYears) =
        { Name = name
          // Calculate distance in miles from light years.
          Distance = lightYears * 5.88e12 |> bigint }

    new(name, distance) = { Name = name; Distance = distance }

    // Display name of star and its distance in parentheses.
    override this.ToString() =
        $"{this.Name, -10} ({this.Distance:N0})"

    interface IComparable<StarInfo> with
        // Compare StarInfo objects by their distance from Earth.
        member this.CompareTo(other: StarInfo) = 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

Kode berikut kemudian membuat instans empat StarInfo objek dan menyimpannya dalam objek generik List<T> . Setelah metode dipanggil List<T>.Sort , StarInfo objek ditampilkan dalam urutan jaraknya dari Bumi.

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)

let stars = ResizeArray()

let star1 = StarInfo("Sirius", 8.6)
stars.Add(star1)
let star2 = StarInfo("Rigel", 1400.)
stars.Add(star2)
let star3 = StarInfo("Castor", 49.)
stars.Add(star3)
let star4 = StarInfo("Antares", 520.)
stars.Add(star4)

stars.Sort()

for star in stars do
    printfn $"{star}"

// 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)

Keterangan

Kelebihan beban CompareTo metode ini mengimplementasikan IComparable<T>.CompareTo metode . Ini digunakan oleh objek koleksi generik untuk memesan item dalam koleksi.

Lihat juga

Berlaku untuk

CompareTo(Object)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Membandingkan instans ini dengan objek tertentu dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai objek yang ditentukan.

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

Parameter

obj: Object

Objek yang akan dibandingkan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan yang menunjukkan hubungan instans saat ini dengan obj parameter , seperti yang ditunjukkan dalam tabel berikut.

Mengembalikan nilai	Deskripsi
Kurang dari nol	Instans saat ini kurang dari `obj`.
Nol	Instans `obj`saat ini sama dengan .
Lebih besar dari nol	Instans saat ini lebih besar dari `obj`, atau parameternya `obj` adalah `null`.

Penerapan

CompareTo(Object)

Pengecualian

ArgumentException

objbukan .BigInteger

Contoh

Contoh berikut memanggil CompareTo(Object) metode untuk membandingkan BigInteger nilai dengan setiap elemen dalam array objek:

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

let values =
    [| BigInteger.Pow(Int64.MaxValue, 10)
       Unchecked.defaultof<bigint>
       bigint 12.534
       Int64.MaxValue
       BigInteger.One |]

let number = bigint UInt64.MaxValue

for value in values do
    try
        printfn $"Comparing {number} with '{value}': {number.CompareTo value}"
    with :? ArgumentException as e ->
        printfn $"Unable to compare the {value.GetType().Name} value {value} with a BigInteger."
// 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

Keterangan

Kelebihan beban CompareTo metode ini mengimplementasikan IComparable.CompareTo metode . Ini digunakan oleh objek koleksi non-generik untuk memesan item dalam koleksi.

Parameter obj harus salah satu dari yang berikut ini:

Objek yang jenis run-time-nya adalah BigInteger.
Variabel Object yang nilainya adalah null. Jika nilai obj parameter adalah null, metode mengembalikan 1, yang menunjukkan bahwa instans saat ini lebih besar dari obj.

Lihat juga

IComparable

Berlaku untuk

CompareTo(UInt64)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Membandingkan instans ini dengan bilangan bulat 64-bit yang tidak ditandatangani dan mengembalikan bilangan bulat yang menunjukkan apakah nilai instans ini kurang dari, sama dengan, atau lebih besar dari nilai bilangan bulat 64-bit yang tidak ditandatangani.

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

Parameter

other: UInt64

Bilangan bulat 64-bit yang tidak ditandatangani untuk dibandingkan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan yang menunjukkan nilai relatif instans ini dan other, seperti yang ditunjukkan dalam tabel berikut.

Mengembalikan nilai	Deskripsi
Kurang dari nol	Instans saat ini kurang dari `other`.
Nol	Instans `other`saat ini sama dengan .
Lebih besar dari nol	Instans saat ini lebih besar dari `other`.

Atribut: CLSCompliantAttribute

Berlaku untuk

Bagikan melalui

BigInteger.CompareTo Metode

Definisi

Overload

CompareTo(Int64)

Parameter

Mengembalikan

Contoh

Keterangan

Berlaku untuk

CompareTo(BigInteger)

Parameter

Mengembalikan

Penerapan

Contoh

Keterangan

Lihat juga

Berlaku untuk

CompareTo(Object)

Parameter

Mengembalikan

Penerapan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

CompareTo(UInt64)

Parameter

Mengembalikan

Berlaku untuk

Sumber Daya Tambahan: