BigInteger.CompareTo Metoda

Reference

Definice

Obor názvů:: System.Numerics

Sestavení:: System.Runtime.Numerics.dll

Sestavení:: System.Numerics.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Porovná hodnotu této instance s jinou hodnotou a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než druhá hodnota.

Přetížení

CompareTo(Int64)	Porovná tuto instanci se znaménkem 64bitové celé číslo a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota 64bitového celého čísla se znaménkem.
CompareTo(BigInteger)	Porovná tuto instanci s sekundou BigInteger a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.
CompareTo(UInt64)	Porovná tuto instanci s 64bitovým celé číslo bez znaménka a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota 64bitového celého čísla bez znaménka.

CompareTo(Int64)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Porovná tuto instanci se znaménkem 64bitové celé číslo a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota 64bitového celého čísla se znaménkem.

public:
 int CompareTo(long other);

public int CompareTo (long other);

member this.CompareTo : int64 -> int

Public Function CompareTo (other As Long) As Integer

Parametry

other: Int64

Podepsané 64bitové celé číslo, které se má porovnat.

Návraty

Int32

Celočíselná hodnota se znaménkem, která označuje vztah této instance k otherhodnotě , jak je znázorněno v následující tabulce.

Vrácená hodnota	Description
Menší než nula	Aktuální instance je menší než `other`.
Žádnou	Aktuální instance se `other`rovná .
Větší než nula	Aktuální instance je větší než `other`.

Příklady

Následující příklad znázorňuje výsledek volání CompareTo(Int64) metody s integrálními hodnotami.

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

Poznámky

Pokud other je Bytehodnota , Int16, Int32, SByte UInt16, nebo UInt32 , je implicitně převedena na Int64 hodnotu při CompareTo(Int64) zavolání metody.

Platí pro

CompareTo(BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Porovná tuto instanci s sekundou BigInteger a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.

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

Parametry

other: BigInteger

Objekt k porovnání

Návraty

Int32

Celočíselná hodnota se znaménkem, která označuje vztah této instance k otherhodnotě , jak je znázorněno v následující tabulce.

Vrácená hodnota	Description
Menší než nula	Aktuální instance je menší než `other`.
Žádnou	Aktuální instance se `other`rovná .
Větší než nula	Aktuální instance je větší než `other`.

Implementuje

CompareTo(T)

Příklady

Následující příklad znázorňuje použití CompareTo(BigInteger) metody k seřazení seznamu StarInfo objektů. Každý StarInfo objekt poskytuje informace o názvu star a jeho vzdálenosti od Země v mílích. StarInfo implementuje IComparable<T> rozhraní, které umožňuje StarInfo řadit objekty podle obecných tříd kolekce. Jeho IComparable<T>.CompareTo implementace pouze zabalí volání do 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

Následující kód pak vytvoří instanci čtyř StarInfo objektů a uloží je do obecného List<T> objektu. Po zavolání List<T>.SortStarInfo metody se objekty zobrazí v pořadí podle jejich vzdálenosti od Země.

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)

Poznámky

Toto přetížení CompareTo metody implementuje metodu IComparable<T>.CompareTo . Používá se obecnými objekty kolekce k seřazení položek v kolekci.

Viz také

Platí pro

CompareTo(Object)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.

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

Parametry

obj: Object

Objekt k porovnání

Návraty

Int32

Celé číslo se znaménkem, které označuje relaci aktuální instance k parametru obj , jak je znázorněno v následující tabulce.

Vrácená hodnota	Description
Menší než nula	Aktuální instance je menší než `obj`.
Žádnou	Aktuální instance se `obj`rovná .
Větší než nula	Aktuální instance je větší než `obj`nebo parametr `obj` je `null`.

Implementuje

CompareTo(Object)

Výjimky

ArgumentException

objnení .BigInteger

Příklady

Následující příklad volá metodu CompareTo(Object) pro porovnání BigInteger hodnoty s každým prvkem v poli objektů:

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

Poznámky

Toto přetížení CompareTo metody implementuje metodu IComparable.CompareTo . Používá se v jiných než obecných objektech kolekce k seřazení položek v kolekci.

Parametr obj musí být jeden z následujících parametrů:

Objekt, jehož typ za běhu je BigInteger.
Proměnná Object , jejíž hodnota je null. Pokud je nullhodnota parametru obj , vrátí metoda hodnotu 1, což znamená, že aktuální instance je větší než obj.

Viz také

IComparable

Platí pro

CompareTo(UInt64)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Porovná tuto instanci s 64bitovým celé číslo bez znaménka a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota 64bitového celého čísla bez znaménka.

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

Parametry

other: UInt64

64bitové celé číslo bez znaménka, které chcete porovnat.

Návraty

Int32

Celé číslo se znaménkem, které označuje relativní hodnotu této instance a other, jak je znázorněno v následující tabulce.

Vrácená hodnota	Description
Menší než nula	Aktuální instance je menší než `other`.
Žádnou	Aktuální instance se `other`rovná .
Větší než nula	Aktuální instance je větší než `other`.

Atributy: CLSCompliantAttribute

Platí pro

BigInteger.CompareTo Metoda

Definice

Přetížení

CompareTo(Int64)

Parametry

Návraty

Příklady

Poznámky

Platí pro

CompareTo(BigInteger)

Parametry

Návraty

Implementuje

Příklady

Poznámky

Viz také

Platí pro

CompareTo(Object)

Parametry

Návraty

Implementuje

Výjimky

Příklady

Poznámky

Viz také

Platí pro

CompareTo(UInt64)

Parametry

Návraty

Platí pro

Váš názor

Další materiály