Int32.CompareTo Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Vergleicht diese Instanz mit einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

Überlädt

CompareTo(Int32)	Vergleicht diese Instanz mit einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

CompareTo(Int32)

Vergleicht diese Instanz mit einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

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

Parameter

value

Int32

Eine zu vergleichende Ganzzahl.

Gibt zurück

Int32

Eine Zahl mit Vorzeichen, die das Verhältnis zwischen dem Wert dieser Instanz und value angibt.

Rückgabewert	BESCHREIBUNG
Kleiner als 0 (null)	Diese Instanz ist kleiner als value.
Zero	Diese Instanz ist gleich value.
Größer als 0 (null)	Diese Instanz ist größer als value.

Implementiert

CompareTo(T)

Beispiele

Das folgende Beispiel veranschaulicht die Int32.CompareTo(Int32) Methode. Zusätzlich zum Anzeigen des von der -Methode zurückgegebenen Werts für vier verschiedene Vergleiche konvertiert sie den Rückgabewert in ein Element der benutzerdefinierten Comparison Enumeration, dessen Wert ebenfalls angezeigt wird.

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

Hinweise

Diese Methode implementiert die System.IComparable<T> Schnittstelle und ist etwas besser als die Int32.CompareTo -Methode, da sie den value Parameter nicht in ein Objekt konvertieren muss.

Abhängig von Ihrer Programmiersprache kann es möglich sein, eine CompareTo Methode zu codieren, bei der der Parametertyp weniger Bits (schmaler) als der Instanztyp aufweist. Dies ist möglich, da einige Programmiersprachen eine implizite Erweiterungskonvertierung durchführen, die den Parameter als Typ mit so vielen Bits wie die Instanz darstellt.

Angenommen, der Instanztyp ist Int32 und der Parametertyp ist Byte. Der Microsoft C#-Compilers generiert Anweisungen, um den Wert des Parameters als Int32darzustellen, und generiert dann eine Int32.CompareTo Methode, die die Werte der Int32 Instanz und der Int32 Parameterdarstellung vergleicht.

Lesen Sie die Dokumentation Ihrer Programmiersprache, um zu ermitteln, ob der Compiler implizite Erweiterungskonvertierungen für numerische Typen ausführt.

Weitere Informationen

• UInt32
• Equals(Object)

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

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

Parameter

value

Object

Ein Vergleichsobjekt oder null.

Gibt zurück

Int32

Eine Zahl mit Vorzeichen, die das Verhältnis zwischen dem Wert dieser Instanz und value angibt.

Rückgabewert	BESCHREIBUNG
Kleiner als 0 (null)	Diese Instanz ist kleiner als value.
Zero	Diese Instanz ist gleich value.
Größer als 0 (null)	Diese Instanz ist größer als value, oder value ist null.

Implementiert

CompareTo(Object)

Ausnahmen

ArgumentException

value ist keine Int32.

Hinweise

Jede Instanz von Int32gilt unabhängig von ihrem Wert als größer als null.

valuemuss oder eine Instanz von Int32seinnull; andernfalls wird eine Ausnahme ausgelöst.

Weitere Informationen

• UInt32
• Equals(Object)