Int32.CompareTo Metoda

Definice

Porovná tuto instanci se zadaným objektem Int32 nebo vrátí označení jejich relativních hodnot.Compares this instance to a specified object or Int32 and returns an indication of their relative values.

Přetížení

CompareTo(Int32)

Porovná tuto instanci na zadané celé číslo se znaménkem 32 a vrátí označení jejich relativních hodnot.Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.Compares this instance to a specified object and returns an indication of their relative values.

CompareTo(Int32)

Porovná tuto instanci na zadané celé číslo se znaménkem 32 a vrátí označení jejich relativních hodnot.Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

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 k porovnání.An integer to compare.

Návraty

Číslo se znaménkem označující relativní hodnoty této instance a value.A signed number indicating the relative values of this instance and value.

Návratová hodnotaReturn Value PopisDescription
Menší než nulaLess than zero Tato instance je menší než value.This instance is less than value.
NulaZero Tato instance je rovna value.This instance is equal to value.
Větší než nulaGreater than zero Tato instance je větší než value.This instance is greater than value.

Implementuje

Příklady

Následující příklad ukazuje Int32.CompareTo(Int32) metodu.The following example demonstrates the Int32.CompareTo(Int32) method. Kromě zobrazení hodnoty vrácené metodou pro čtyři odlišná porovnání převede návratovou hodnotu na člen vlastního Comparison výčtu, jehož hodnota se zobrazí také.In addition to displaying the value returned by the method for four different comparisons, it converts the return value to a member of the custom Comparison enumeration, whose value it also displays.

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).
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ě lepší Int32.CompareTo než metodu, protože value není nutné převést parametr na objekt.This method implements the System.IComparable<T> interface and performs slightly better than the Int32.CompareTo method because it does not have to convert the value parameter to an object.

V závislosti na programovacím jazyce může být možné kódovat CompareTo metodu, kde typ parametru má méně bitů (je užší) než typ instance.Depending on your programming language, it might be possible to code a CompareTo method where the parameter type has fewer bits (is narrower) than the instance type. 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.This is possible because some programming languages perform an implicit widening conversion that represents the parameter as a type with as many bits as the instance.

Předpokládejme například, že typ instance je Int32 a typ parametru je. ByteFor example, suppose the instance type is Int32 and the parameter type is Byte. Kompilátor společnosti C# Microsoft generuje pokyny, které Int32reprezentují hodnotu parametru jako Int32.CompareTo , a pak vygeneruje Int32 metodu, která porovnává hodnoty instance a Int32 parametru. obrázek.The Microsoft C# compiler generates instructions to represent the value of the parameter as an Int32, then generates a Int32.CompareTo method that compares the values of the Int32 instance and the Int32 parameter representation.

V dokumentaci pro programovací jazyk zjistíte, zda jeho kompilátor provádí implicitní rozšiřující převody u číselných typů.Consult your programming language's documentation to determine whether its compiler performs implicit widening conversions on numeric types.

Viz také

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.Compares this instance to a specified object and returns an indication of their relative values.

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 pro porovnání, nebo null.An object to compare, or null.

Návraty

Číslo se znaménkem označující relativní hodnoty této instance a value.A signed number indicating the relative values of this instance and value.

Návratová hodnotaReturn Value PopisDescription
Menší než nulaLess than zero Tato instance je menší než value.This instance is less than value.
NulaZero Tato instance je rovna value.This instance is equal to value.
Větší než nulaGreater than zero Tato instance je větší než value.This instance is greater than value. -nebo--or- valueje null.value is null.

Implementuje

Výjimky

valueInt32není.value is not an Int32.

Poznámky

Jakékoli instance Int32, bez ohledu na její hodnotu, se považují za větší nullnež.Any instance of Int32, regardless of its value, is considered greater than null.

valuemusí být null nebo Int32instance; v opačném případě je vyvolána výjimka.value must be null or an instance of Int32; otherwise, an exception is thrown.

Viz také

Platí pro