Int32.CompareTo Methode

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Vergelijkt dit exemplaar met een opgegeven 32-bits geheel getal en retourneert een indicatie van de relatieve waarden.

Overloads

Name	Description
CompareTo(Int32)	Vergelijkt dit exemplaar met een opgegeven 32-bits geheel getal en retourneert een indicatie van de relatieve waarden.
CompareTo(Object)	Vergelijkt dit exemplaar met een opgegeven object en retourneert een indicatie van de relatieve waarden.

CompareTo(Int32)

Vergelijkt dit exemplaar met een opgegeven 32-bits geheel getal en retourneert een indicatie van de relatieve waarden.

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

Parameters

value: Int32

Een geheel getal dat moet worden vergeleken.

Retouren

Int32

Een ondertekend getal dat de relatieve waarden van dit exemplaar aangeeft en value.

Retourwaarde	Beschrijving
Kleiner dan nul	Dit exemplaar is kleiner dan `value`.
Nul	Dit exemplaar is gelijk aan `value`.
Groter dan nul	Dit exemplaar is groter dan `value`.

Implementeringen

CompareTo(T)

Voorbeelden

In het volgende voorbeeld ziet u de Int32.CompareTo(Int32) methode. Naast het weergeven van de waarde die wordt geretourneerd door de methode voor vier verschillende vergelijkingen, wordt de retourwaarde geconverteerd naar een lid van de aangepaste Comparison opsomming, waarvan de waarde ook wordt weergegeven.

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

Opmerkingen

Deze methode implementeert de System.IComparable<T> interface en presteert iets beter dan de Int32.CompareTo methode omdat deze de value parameter niet hoeft te converteren naar een object.

Afhankelijk van uw programmeertaal is het mogelijk om een CompareTo methode te codeeren waarbij het parametertype minder bits heeft (is smaller) dan het exemplaartype. Dit is mogelijk omdat sommige programmeertalen een impliciete widening conversie uitvoeren die de parameter vertegenwoordigt als een type met zoveel bits als het exemplaar.

Stel dat het exemplaartype is Int32 en het parametertype is Byte. De Microsoft C#-compiler genereert instructies voor het weergeven van de waarde van de parameter als een Int32 en genereert vervolgens een methode Int32.CompareTo waarmee de waarden van het Int32-exemplaar en de Int32 parameterweergave worden vergeleken.

Raadpleeg de documentatie van uw programmeertaal om te bepalen of de compiler impliciete widening conversies uitvoert op numerieke typen.

Zie ook

Van toepassing op

CompareTo(Object)

Vergelijkt dit exemplaar met een opgegeven object en retourneert een indicatie van de relatieve waarden.

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

Parameters

value: Object

Een object dat moet worden vergeleken, of null.

Retouren

Int32

Een ondertekend getal dat de relatieve waarden van dit exemplaar aangeeft en value.

Retourwaarde	Beschrijving
Kleiner dan nul	Dit exemplaar is kleiner dan `value`.
Nul	Dit exemplaar is gelijk aan `value`.
Groter dan nul	Dit exemplaar is groter dan `value`, of `value` is `null`.

Implementeringen

CompareTo(Object)

Uitzonderingen

ArgumentException

value is geen Int32.

Opmerkingen

Elk exemplaar van Int32, ongeacht de waarde, wordt beschouwd als groter dan null.

value moet of null een instantie van Int32; anders wordt er een uitzondering gegenereerd.

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?