Int32.CompareTo Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Porovná tuto instanci se zadaným 32bitovým celočíselným znaménkem a vrátí indikaci jejich relativních hodnot.

Přetížení

CompareTo(Int32)	Porovná tuto instanci se zadaným 32bitovým celočíselným znaménkem a vrátí indikaci jejich relativních hodnot.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

CompareTo(Int32)

Zdroj:

Int32.cs

Porovná tuto instanci se zadaným 32bitovým celočíselným znaménkem a vrátí indikaci jejich relativních hodnot.

public:
 virtual int CompareTo(int value);

public int CompareTo (int value);

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

Public Function CompareTo (value As Integer) As Integer

Parametry

value

Int32

Celé číslo, které chcete porovnat.

Návraty

Int32

Podepsané číslo označující relativní hodnoty této instance a value.

Návratová hodnota	Description
Menší než nula	Tato instance je menší než value.
Žádnou	Tato instance se rovná hodnotě value.
Větší než nula	Tato instance je větší než value.

Implementuje

CompareTo(T)

Příklady

Následující příklad ukazuje metodu Int32.CompareTo(Int32) . Kromě zobrazení hodnoty vrácené metodou pro čtyři různá porovnání převede návratovou hodnotu na člena vlastního Comparison výčtu, jehož hodnotu také zobrazí.

using System;

enum Comparison {
   LessThan=-1, Equal=0, GreaterThan=1};

public class ValueComparison
{
   public static void Main()
   {
      int mainValue = 16325;
      int zeroValue = 0;
      int negativeValue = -1934;
      int positiveValue = 903624;
      int sameValue = 16325;

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, zeroValue,
                        mainValue.CompareTo(zeroValue),
                        (Comparison) mainValue.CompareTo(zeroValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, sameValue,
                        mainValue.CompareTo(sameValue),
                        (Comparison) mainValue.CompareTo(sameValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, negativeValue,
                        mainValue.CompareTo(negativeValue),
                        (Comparison) mainValue.CompareTo(negativeValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, positiveValue,
                        mainValue.CompareTo(positiveValue),
                        (Comparison) mainValue.CompareTo(positiveValue));
   }
}
// The example displays the following output:
//       Comparing 16325 and 0: 1 (GreaterThan).
//       Comparing 16325 and 16325: 0 (Equal).
//       Comparing 16325 and -1934: 1 (GreaterThan).
//       Comparing 16325 and 903624: -1 (LessThan).

open System

type Comparison =
    | LessThan = -1 
    | Equal = 0
    | GreaterThan = 1

let mainValue = 16325
let zeroValue = 0
let negativeValue = -1934
let positiveValue = 903624
let sameValue = 16325

printfn $"Comparing {mainValue} and {zeroValue}: {mainValue.CompareTo zeroValue} ({enum<Comparison>(mainValue.CompareTo zeroValue)})."

printfn $"Comparing {mainValue} and {sameValue}: {mainValue.CompareTo sameValue} ({enum<Comparison>(mainValue.CompareTo sameValue)})."

printfn $"Comparing {mainValue} and {negativeValue}: {mainValue.CompareTo negativeValue} ({enum<Comparison>(mainValue.CompareTo negativeValue)})." 

printfn $"Comparing {mainValue} and {positiveValue}: {mainValue.CompareTo positiveValue} ({enum<Comparison>(mainValue.CompareTo positiveValue)})."

// The example displays the following output:
//       Comparing 16325 and 0: 1 (GreaterThan).
//       Comparing 16325 and 16325: 0 (Equal).
//       Comparing 16325 and -1934: 1 (GreaterThan).
//       Comparing 16325 and 903624: -1 (LessThan).

Public Enum Comparison As Integer
   LessThan = -1
   Equal = 0
   GreaterThan = 1
End Enum

Module ValueComparison
   Public Sub Main()
      Dim mainValue As Integer = 16325
      Dim zeroValue As Integer = 0
      Dim negativeValue As Integer = -1934
      Dim positiveValue As Integer = 903624
      Dim sameValue As Integer = 16325
      
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, zeroValue, _
                        mainValue.CompareTo(zeroValue), _
                        CType(mainValue.CompareTo(zeroValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, sameValue, _
                        mainValue.CompareTo(sameValue), _
                        CType(mainValue.CompareTo(sameValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, negativeValue, _
                        mainValue.CompareTo(negativeValue), _
                        CType(mainValue.CompareTo(negativeValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, positiveValue, _
                        mainValue.CompareTo(positiveValue), _
                        CType(mainValue.CompareTo(positiveValue), Comparison))
   End Sub
End Module
' The example displays the following output:
'       Comparing 16325 and 0: 1 (GreaterThan).
'       Comparing 16325 and 16325: 0 (Equal).
'       Comparing 16325 and -1934: 1 (GreaterThan).
'       Comparing 16325 and 903624: -1 (LessThan).

Poznámky

Tato metoda implementuje System.IComparable<T> rozhraní a funguje o něco lépe než Int32.CompareTo metoda, protože nemusí převést value parametr na objekt.

V závislosti na programovacím jazyce může být možné kódovat metodu CompareTo , kde typ parametru má méně bitů (je užší) než typ instance. Je to možné, protože některé programovací jazyky provádějí implicitní rozšiřující převod, který představuje parametr jako typ s tolika bity, kolik bitů má instance.

Předpokládejme například, že typ instance je Int32 a typ parametru je Byte. Kompilátor Microsoft jazyka C# vygeneruje instrukce k reprezentaci hodnoty parametru jako Int32, a pak vygeneruje metoduInt32.CompareTo, která porovnává hodnoty Int32 instance a reprezentace parametruInt32.

V dokumentaci pro programovací jazyk zjistíte, zda jeho kompilátor provádí implicitní rozšiřující převody u číselných typů.

Viz také

• UInt32
• Equals(Object)

CompareTo(Object)

Zdroj:

Int32.cs

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

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

Parametry

value

Object

Objekt, který chcete porovnat, nebo null.

Návraty

Int32

Podepsané číslo označující relativní hodnoty této instance a value.

Návratová hodnota	Description
Menší než nula	Tato instance je menší než value.
Žádnou	Tato instance se rovná hodnotě value.
Větší než nula	Tato instance je větší než value, nebo value je null.

Implementuje

CompareTo(Object)

Výjimky

ArgumentException

valuenení .Int32

Poznámky

Jakákoli instance objektu Int32bez ohledu na jeho hodnotu je považována za větší než null.

value musí být null nebo instance ; Int32jinak dojde k výjimce.

Viz také

• UInt32
• Equals(Object)