Int32.CompareTo Metoda

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Porównuje to wystąpienie z określoną 32-bitową liczbą całkowitą ze znakiem i zwraca wskazanie ich względnych wartości.

Przeciążenia

CompareTo(Int32)	Porównuje to wystąpienie z określoną 32-bitową liczbą całkowitą ze znakiem i zwraca wskazanie ich względnych wartości.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.

CompareTo(Int32)

Źródło:

Int32.cs

Porównuje to wystąpienie z określoną 32-bitową liczbą całkowitą ze znakiem i zwraca wskazanie ich względnych wartości.

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

Liczba całkowita do porównania.

Zwraca

Int32

Podpisany numer wskazujący względne wartości tego wystąpienia i value.

Wartość zwracana	Opis
Mniej niż zero	To wystąpienie jest mniejsze niż value.
Zero	To wystąpienie jest równe value.
Większe od zera	To wystąpienie jest większe niż value.

Implementuje

CompareTo(T)

Przykłady

W poniższym przykładzie pokazano metodę Int32.CompareTo(Int32) . Oprócz wyświetlania wartości zwracanej przez metodę dla czterech różnych porównań, konwertuje wartość zwracaną na element członkowski wyliczenia niestandardowego Comparison , którego wartość jest również wyświetlana.

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).

Uwagi

Ta metoda implementuje System.IComparable<T> interfejs i działa nieco lepiej niż Int32.CompareTo metoda, ponieważ nie musi konwertować parametru value na obiekt.

W zależności od języka programowania można kodować metodę CompareTo , w której typ parametru ma mniej bitów (jest węższy) niż typ wystąpienia. To jest możliwe, ponieważ w niektórych językach programowania jest wykonywana niejawna konwersja poszerzająca, która powoduje reprezentowanie parametru jako typu z taką samą liczbą bitów jak liczba bitów wystąpienia.

Załóżmy na przykład, że typ wystąpienia to Int32 , a typ parametru to Byte. Kompilator języka C# Microsoft generuje instrukcje reprezentujące wartość parametru jako Int32parametr , a następnie generuje metodęInt32.CompareTo, która porównuje wartości Int32 wystąpienia i reprezentację parametruInt32.

Aby ustalić, czy kompilator metody dokonuje na typach liczbowych niejawnych konwersji poszerzających, zajrzyj do dokumentacji języka programowania.

Zobacz też

• UInt32
• Equals(Object)

CompareTo(Object)

Źródło:

Int32.cs

Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich względnych wartości.

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

Obiekt do porównania lub null.

Zwraca

Int32

Podpisany numer wskazujący względne wartości tego wystąpienia i value.

Wartość zwracana	Opis
Mniej niż zero	To wystąpienie jest mniejsze niż value.
Zero	To wystąpienie jest równe value.
Większe od zera	To wystąpienie jest większe niż value, lub value ma nullwartość .

Implementuje

CompareTo(Object)

Wyjątki

ArgumentException

value nie jest elementem Int32.

Uwagi

Każde wystąpienie klasy Int32, niezależnie od jego wartości, jest uznawane za większe niż null.

value musi być null lub wystąpieniem Int32obiektu ; w przeciwnym razie zgłaszany jest wyjątek.

Zobacz też

• UInt32
• Equals(Object)