Int32.CompareTo Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

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

Přetížení

Name	Description
CompareTo(Int32)	Porovná tuto instanci se zadaným 32bitovým celým číslem se znaménkem a vrátí indikaci jejich relativních hodnot.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrátí indikaci jejich relativních hodnot.

CompareTo(Int32)

Zdroj:

Int32.cs

Porovná tuto instanci se zadaným 32bitovým celým číslem se 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

Číslo se znaménkem označujícím relativní hodnoty této instance a value.

Návratová hodnota	Popis
Menší než nula	Tato instance je menší než value.
Nula	Tato instance je rovna 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í Comparison výčtu, jehož hodnota se zobrazí také.

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 provádí mírně 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é zakódovat metodu CompareTo , ve které má typ parametru 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 jazyka C# Microsoft generuje instrukce představující hodnotu parametru jako Int32 a pak vygeneruje metodu Int32.CompareTo, která porovnává hodnoty instance Int32 a reprezentaci parametru Int32.

Pokud chcete zjistit, jestli kompilátor provádí implicitní rozšiřující převody u číselných typů, projděte si dokumentaci k programovacímu jazyku.

Viz také

• UInt32
• Equals(Object)

CompareTo(Object)

Zdroj:

Int32.cs

Porovná tuto instanci se zadaným objektem a vrátí indikaci jejich relativních hodnot.

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

Číslo se znaménkem označujícím relativní hodnoty této instance a value.

Návratová hodnota	Popis
Menší než nula	Tato instance je menší než value.
Nula	Tato instance je rovna value.
Větší než nula	Tato instance je větší než valuenebo value je null.

Implementuje

CompareTo(Object)

Výjimky

ArgumentException

valuenení .Int32

Poznámky

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

value musí být null nebo instance Int32; v opačném případě je vyvolán výjimka.

Viz také

• UInt32
• Equals(Object)