Article
11/18/2011

Int32.CompareTo Method (Int32)

Microsoft Silverlight will reach end of support after October 2021. Learn more.

Compares this instance to a specified 32-bit signed integer and returns an integer that indicates whether the value of this instance is greater than, less than, or equal to the value of the specified 32-bit signed integer.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Function CompareTo ( _
    value As Integer _
) As Integer

public int CompareTo(
    int value
)

Parameters

value
Type: System.Int32
An integer to compare.

Return Value

Type: System.Int32
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

IComparable<T>.CompareTo(T)

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.

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.

Public Enum Comparison As Integer
   LessThan = -1
   Equal = 0
   GreaterThan = 1
End Enum

Module Example
   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      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

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).", _
                        mainValue, zeroValue, _
                        mainValue.CompareTo(zeroValue), _
                        CType(mainValue.CompareTo(zeroValue), Comparison)) _
                        & vbCrLf

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).", _
                        mainValue, sameValue, _
                        mainValue.CompareTo(sameValue), _
                        CType(mainValue.CompareTo(sameValue), Comparison)) _
                        & vbCrLf

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).", _
                        mainValue, negativeValue, _
                        mainValue.CompareTo(negativeValue), _
                        CType(mainValue.CompareTo(negativeValue), Comparison)) _
                        & vbCrLf

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).", _
                        mainValue, positiveValue, _
                        mainValue.CompareTo(positiveValue), _
                        CType(mainValue.CompareTo(positiveValue), Comparison)) _
                        & vbCrLf
   End Sub
End Module

using System;

enum Comparison
{
   LessThan = -1, Equal = 0, GreaterThan = 1
};

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      int mainValue = 16325;
      int zeroValue = 0;
      int negativeValue = -1934;
      int positiveValue = 903624;
      int sameValue = 16325;

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, zeroValue,
                        mainValue.CompareTo(zeroValue),
                        (Comparison)mainValue.CompareTo(zeroValue)) + "\n";

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, sameValue,
                        mainValue.CompareTo(sameValue),
                        (Comparison)mainValue.CompareTo(sameValue)) + "\n";

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, negativeValue,
                        mainValue.CompareTo(negativeValue),
                        (Comparison)mainValue.CompareTo(negativeValue)) + "\n";

      outputBlock.Text += String.Format("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, positiveValue,
                        mainValue.CompareTo(positiveValue),
                        (Comparison)mainValue.CompareTo(positiveValue)) + "\n";
   }
}

Version Information

Silverlight

Supported in: 5, 4, 3

Silverlight for Windows Phone

Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0

XNA Framework

Supported in: Xbox 360, Windows Phone OS 7.0

Platforms

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.

Share via