Int32.CompareTo Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Jämför den här instansen med ett angivet 32-bitars signerat heltal och returnerar en indikation på deras relativa värden.

Överlagringar

Name Description
CompareTo(Int32)

Jämför den här instansen med ett angivet 32-bitars signerat heltal och returnerar en indikation på deras relativa värden.
CompareTo(Object)

Jämför den här instansen med ett angivet objekt och returnerar en indikation på deras relativa värden.

CompareTo(Int32)

Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs

Jämför den här instansen med ett angivet 32-bitars signerat heltal och returnerar en indikation på deras relativa värden.

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

Parametrar

value
Int32

Ett heltal att jämföra.

Returer

Int32

Ett signerat tal som anger de relativa värdena för den här instansen och value.

Returvärde Beskrivning
Mindre än noll Den här instansen är mindre än value.
Noll Den här instansen är lika med value.
Större än noll Den här instansen är större än value.

Implementeringar

CompareTo(T)

Exempel

I följande exempel visas Int32.CompareTo(Int32) metoden. Förutom att visa värdet som returneras av metoden för fyra olika jämförelser konverteras returvärdet till en medlem i den anpassade Comparison uppräkningen, vars värde det också visar.

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

Kommentarer

Den här metoden implementerar System.IComparable<T>-gränssnittet och fungerar något bättre än metoden Int32.CompareTo eftersom den inte behöver konvertera parametern value till ett objekt.

Beroende på programmeringsspråket kan det vara möjligt att koda en CompareTo metod där parametertypen har färre bitar (är smalare) än instanstypen. Detta är möjligt eftersom vissa programmeringsspråk utför en implicit breddningskonvertering som representerar parametern som en typ med så många bitar som instansen.

Anta till exempel att instanstypen är Int32 och att parametertypen är Byte. Kompilatorn Microsoft C# genererar instruktioner för att representera värdet för parametern som en Int32 och genererar sedan en metod Int32.CompareTo som jämför värdena för instansen Int32 och parameterrepresentationen Int32.

Läs dokumentationen för programmeringsspråket för att avgöra om kompilatorn utför implicita breddningskonverteringar på numeriska typer.

Se även

Gäller för

CompareTo(Object)

Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs
Källa:
Int32.cs

Jämför den här instansen med ett angivet objekt och returnerar en indikation på deras relativa värden.

public:
 virtual int CompareTo(System::Object ^ value);
public int CompareTo(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

Parametrar

value
Object

Ett objekt att jämföra, eller null.

Returer

Int32

Ett signerat tal som anger de relativa värdena för den här instansen och value.

Returvärde Beskrivning
Mindre än noll Den här instansen är mindre än value.
Noll Den här instansen är lika med value.
Större än noll Den här instansen är större än value, eller value är null.

Implementeringar

CompareTo(Object)

Undantag

ArgumentException

value är inte en Int32.

Kommentarer

Alla instanser av Int32, oavsett dess värde, anses vara större än null.

value måste vara null eller en instans av Int32. Annars utlöses ett undantag.

Se även

Gäller för