Int32.CompareTo Method

Definition

Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

Overloads

CompareTo(Int32)

Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

CompareTo(Object)

Compares this instance to a specified object and returns an indication of their relative values.

CompareTo(Int32)

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

Parameters

value
Int32

An integer to compare.

Returns

A signed number indicating the relative values of this instance and value.

Return Value Description
Less than zero This instance is less than value.
Zero This instance is equal to value.
Greater than zero This instance is greater than value.

Implements

Examples

The following example demonstrates the Int32.CompareTo(Int32) method. 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).
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).

Remarks

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.

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

For example, suppose the instance type is Int32 and the parameter type is Byte. 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.

Consult your programming language's documentation to determine whether its compiler performs implicit widening conversions on numeric types.

See also

Applies to

CompareTo(Object)

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

An object to compare, or null.

Returns

A signed number indicating the relative values of this instance and value.

Return Value Description
Less than zero This instance is less than value.
Zero This instance is equal to value.
Greater than zero This instance is greater than value, or value is null.

Implements

Exceptions

value is not an Int32.

Remarks

Any instance of Int32, regardless of its value, is considered greater than null.

value must be null or an instance of Int32; otherwise, an exception is thrown.

See also

Applies to