Int32.CompareTo Metodo

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

Parametri

Valori restituiti

Numero con segno che indica i valori relativi di questa istanza e value.

Valore restituito	Descrizione
Minore di zero	Questa istanza è minore di value.
Zero	Questa istanza è uguale a value.
Maggiore di zero	Questa istanza è maggiore di value.

Implementazioni

Esempio

Nell'esempio seguente viene illustrato il Int32.CompareTo(Int32) metodo . Oltre a visualizzare il valore restituito dal metodo per quattro confronti diversi, converte il valore restituito in un membro dell'enumerazione personalizzata Comparison , il cui valore viene visualizzato anche.

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

Commenti

Questo metodo implementa l'interfaccia System.IComparable<T> ed esegue prestazioni leggermente migliori rispetto al metodo Int32.CompareTo perché non è necessario convertire il parametro value in un oggetto .

A seconda del linguaggio di programmazione, potrebbe essere possibile codificare un metodo CompareTo in cui il tipo di parametro ha meno bit (è più piccolo) rispetto al tipo di istanza. Ciò è possibile perché alcuni linguaggi di programmazione eseguono una conversione implicita di estensione che rappresenta il parametro come tipo con il maggior numero di bit dell'istanza.

Si supponga, ad esempio, che il tipo di istanza sia Int32 e che il tipo di parametro sia Byte. Il compilatore C# Microsoft genera istruzioni per rappresentare il valore del parametro come Int32, quindi genera un metodo Int32.CompareTo che confronta i valori dell'istanza Int32 e la rappresentazione del parametro Int32.

Consultare la documentazione del linguaggio di programmazione per determinare se il compilatore esegue conversioni implicite di ampliamento sui tipi numerici.

Vedi anche

• UInt32
• Equals(Object)

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

Parametri

Valori restituiti

Numero con segno che indica i valori relativi di questa istanza e value.

Valore restituito	Descrizione
Minore di zero	Questa istanza è minore di value.
Zero	Questa istanza è uguale a value.
Maggiore di zero	Questa istanza è maggiore di valueo value è null.

Implementazioni

Eccezioni

Commenti

Qualsiasi istanza di Int32, indipendentemente dal relativo valore, viene considerata maggiore di null.

value deve essere null o un'istanza di Int32; in caso contrario, viene generata un'eccezione.

Vedi anche

• UInt32
• Equals(Object)