BigInteger.CompareTo Metódus

Definíció

Névtér:

System.Numerics

Szerelvények:

netstandard.dll, System.Runtime.Numerics.dll

Összehasonlítja a példány értékét egy másik értékkel, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb, egyenlő vagy nagyobb-e, mint a másik érték.

Túlterhelések

Name	Description
CompareTo(Int64)	Összehasonlítja ezt a példányt egy aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint az aláírt 64 bites egész szám értéke.
CompareTo(BigInteger)	Összehasonlítja ezt a példányt egy másodperccel BigInteger , és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.
CompareTo(Object)	Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.
CompareTo(UInt64)	Összehasonlítja ezt a példányt egy nem aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb, egyenlő vagy nagyobb-e, mint az aláíratlan 64 bites egész szám értéke.

CompareTo(Int64)

Forrás:

BigInteger.cs

Összehasonlítja ezt a példányt egy aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint az aláírt 64 bites egész szám értéke.

public:
 int CompareTo(long other);

public int CompareTo(long other);

member this.CompareTo : int64 -> int

Public Function CompareTo (other As Long) As Integer

Paraméterek

other

Int64

Az összehasonlítandó aláírt 64 bites egész szám.

Válaszok

Int32

Aláírt egész szám, amely a példány és a következő othertáblázatban látható kapcsolatát jelzi.

Visszaadott érték	Leírás
Nullánál kisebb	Az aktuális példány kisebb, mint other.
Nulla	Az aktuális példány egyenlő other.
Nullánál nagyobb	Az aktuális példány nagyobb, mint other.

Példák

Az alábbi példa a metódus integrálértékekkel való meghívásának CompareTo(Int64) eredményét mutatja be.

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

Megjegyzések

Ha other egy Byte, Int16, Int32, SByte, UInt16vagy UInt32 érték, akkor a metódus meghívásakor implicit módon konvertálja azt Int64 értékkéCompareTo(Int64).

CompareTo(BigInteger)

Forrás:

BigInteger.cs

Összehasonlítja ezt a példányt egy másodperccel BigInteger , és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.

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

Paraméterek

other

BigInteger

Az összehasonlítandó objektum.

Válaszok

Int32

Aláírt egész szám, amely a példány és a következő othertáblázatban látható kapcsolatát jelzi.

Visszaadott érték	Leírás
Nullánál kisebb	Az aktuális példány kisebb, mint other.
Nulla	Az aktuális példány egyenlő other.
Nullánál nagyobb	Az aktuális példány nagyobb, mint other.

Megvalósítás

CompareTo(T)

Példák

Az alábbi példa azt mutatja be, hogy a CompareTo(BigInteger) metódus milyen módon rendeli meg az StarInfo objektumok listáját. Minden StarInfo objektum információt nyújt egy csillag nevéről és a Földtől való távolságáról mérföldekben. StarInfo implementálja az IComparable<T> interfészt, amely lehetővé teszi StarInfo az objektumok általános gyűjteményosztályok szerinti rendezését. Az IComparable<T>.CompareTo implementáció csak becsomagol egy hívást.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

Az alábbi kód ezután négy StarInfo objektumot példányosít, és egy általános List<T> objektumban tárolja őket. A metódus meghívása List<T>.SortStarInfo után az objektumok a Földtől való távolságuk sorrendjében jelennek meg.

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)

Megjegyzések

A metódus túlterhelése CompareTo implementálja a metódust IComparable<T>.CompareTo . Az általános gyűjteményobjektumok a gyűjtemény elemeinek rendelésére használják.

Lásd még

• Compare(BigInteger, BigInteger)
• IComparable<T>
• Equals(BigInteger)

CompareTo(Object)

Forrás:

BigInteger.cs

Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.

public:
 virtual int CompareTo(System::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

Paraméterek

obj

Object

Az összehasonlítandó objektum.

Válaszok

Int32

Aláírt egész szám, amely az aktuális példány és a obj paraméter közötti kapcsolatot jelzi az alábbi táblázatban látható módon.

Visszaadott érték	Leírás
Nullánál kisebb	Az aktuális példány kisebb, mint obj.
Nulla	Az aktuális példány egyenlő obj.
Nullánál nagyobb	Az aktuális példány nagyobb, mint obj, vagy a obj paraméter .null

Megvalósítás

CompareTo(Object)

Kivételek

ArgumentException

obj nem egy BigInteger.

Példák

Az alábbi példa meghívja a metódust, CompareTo(Object) hogy hasonlítson össze egy BigInteger értéket egy objektumtömb minden elemével:

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

Megjegyzések

A metódus túlterhelése CompareTo implementálja a metódust IComparable.CompareTo . A nem általános gyűjteményobjektumok a gyűjtemény elemeinek rendelésére használják.

A obj paraméternek a következők egyikének kell lennie:

• Olyan objektum, amelynek futásideje a BigIntegerkövetkező: .

• Egy Object változó, amelynek értéke .null Ha a obj paraméter értéke, nulla metódus 1 értéket ad vissza, ami azt jelzi, hogy az aktuális példány nagyobb, mint obj.

Lásd még

• IComparable

CompareTo(UInt64)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

Összehasonlítja ezt a példányt egy nem aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb, egyenlő vagy nagyobb-e, mint az aláíratlan 64 bites egész szám értéke.

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

Paraméterek

other

UInt64

Az összehasonlítandó aláíratlan 64 bites egész szám.

Válaszok

Int32

Aláírt egész szám, amely a példány relatív értékét jelzi, és otheraz alábbi táblázatban látható módon.

Visszaadott érték	Leírás
Nullánál kisebb	Az aktuális példány kisebb, mint other.
Nulla	Az aktuális példány egyenlő other.
Nullánál nagyobb	Az aktuális példány nagyobb, mint other.

Attribútumok

CLSCompliantAttribute