Int32.CompareTo Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Confronta questa istanza con un intero con segno a 32 bit specificato e restituisce un'indicazione dei valori relativi.

Overload

CompareTo(Int32)

Confronta questa istanza con un intero con segno a 32 bit specificato e restituisce un'indicazione dei valori relativi.
CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un'indicazione dei valori relativi.

CompareTo(Int32)

Origine:
Int32.cs
Origine:
Int32.cs
Origine:
Int32.cs

Confronta questa istanza con un intero con segno a 32 bit specificato e restituisce un'indicazione dei valori relativi.

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

value
Int32

Intero da confrontare.

Restituisce

Int32

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

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

Implementazioni

CompareTo(T)

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 leggermente meglio del Int32.CompareTo metodo perché non deve convertire il value parametro in un oggetto.

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

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

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

Vedi anche

Si applica a

CompareTo(Object)

Origine:
Int32.cs
Origine:
Int32.cs
Origine:
Int32.cs

Confronta questa istanza con un oggetto specificato e restituisce un'indicazione dei valori relativi.

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

Parametri

value
Object

Oggetto da confrontare o null.

Restituisce

Int32

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

Valore restituito Descrizione
Minore di zero L'istanza è minore di value.
Zero L'istanza è uguale a value.
Maggiore di zero L'istanza è maggiore di value oppure value è null.

Implementazioni

CompareTo(Object)

Eccezioni

ArgumentException

value non è un elemento Int32.

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

Si applica a