Single.CompareTo Metodo

Definizione

Spazio dei nomi:: System

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll, System.Runtime.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Confronta questa istanza con un oggetto specificato o con un'altra Single istanza e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'oggetto specificato o dell'altra Single istanza.

Overload

Nome	Descrizione
CompareTo(Object)	Confronta questa istanza con un oggetto specificato e restituisce un numero intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'oggetto specificato.
CompareTo(Single)	Confronta questa istanza con un numero a virgola mobile e precisione singola specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero a virgola mobile a precisione singola specificato.

CompareTo(Object)

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Confronta questa istanza con un oggetto specificato e restituisce un numero intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'oggetto specificato.

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.

Valori restituiti

Int32

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

Valore restituito	Descrizione
Minore di zero	Questa istanza è minore di `value`o questa istanza non è un numero (NaN) ed `value` è un numero.
Zero	Questa istanza è uguale a `value`oppure questa istanza e il valore non sono entrambi un numero (NaN), PositiveInfinityo NegativeInfinity.
Maggiore di zero	Questa istanza è maggiore di `value`, OPPURE questa istanza è un numero e `value` non è un numero (NaN), OR `value` è `null`.

Implementazioni

CompareTo(Object)

Eccezioni

ArgumentException

value non è un oggetto Single.

Esempio

Nell'esempio di codice seguente viene illustrato il CompareTo metodo .

obj1 = (Single)450;

if (a.CompareTo(obj1) < 0)
{
    Console.WriteLine("{0} is less than {1}.", a.ToString(), obj1.ToString());
}

if (a.CompareTo(obj1) > 0)
{
    Console.WriteLine("{0} is greater than {1}.", a.ToString(), obj1.ToString());
}

if (a.CompareTo(obj1) == 0)
{
    Console.WriteLine("{0} equals {1}.", a.ToString(), obj1.ToString());
}

let obj1 = single 450

if a.CompareTo obj1 < 0 then
    printfn $"{a} is less than {obj1}."

if a.CompareTo obj1 > 0 then
    printfn $"{a} is greater than {obj1}."

if a.CompareTo obj1 = 0 then
    printfn $"{a} equals {obj1}."

Obj1 = CType(450, Single)

If A.CompareTo(Obj1) < 0 Then
    Console.WriteLine(A.ToString() + " is less than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) > 0) Then
    Console.WriteLine(A.ToString() + " is greater than " + Obj1.ToString() + ".")
End If

If (A.CompareTo(Obj1) = 0) Then
    Console.WriteLine(A.ToString() + " equals " + Obj1.ToString() + ".")
End If

Commenti

I valori devono essere identici per essere considerati uguali. In particolare, quando i valori a virgola mobile dipendono da più operazioni matematiche, è comune perdere precisione e per i relativi valori essere quasi identici, ad eccezione delle cifre meno significative. Per questo motivo, il valore restituito del metodo CompareTo può sembrare sorprendente a volte. Ad esempio, la moltiplicazione per un determinato valore seguito dalla divisione per lo stesso valore deve produrre il valore originale, ma nell'esempio seguente il valore calcolato risulta essere maggiore del valore originale. Mostrando tutte le cifre significative dei due valori usando la stringa di formato numerico standard "R" indica che il valore calcolato differisce dal valore originale nelle cifre meno significative. Per informazioni sulla gestione di tali confronti, vedere la sezione Osservazioni del metodo Equals(Single).

Anche se un oggetto il cui valore è NaN non è considerato uguale a un altro oggetto il cui valore è NaN (anche se stesso), l'interfaccia IComparable<T> richiede che A.CompareTo(A) restituire zero.

CompareTo(System.Object)

Il parametro value deve essere null o un'istanza di Single; in caso contrario, viene generata un'eccezione. Qualsiasi istanza di Single, indipendentemente dal relativo valore, viene considerata maggiore di null.

using System;

public class Example
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       object value2 = value1 * operand / operand;
       Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}");
       Console.WriteLine();
       Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = box (value1 * operand / operand)
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example2
    Public Sub Main()
        Dim value1 As Single = 16.5457
        Dim value2 As Object = value1 * CSng(3.8899982) / CSng(3.8899982)
        Console.WriteLine("Comparing {0} and {1}: {2}",
                          value1, value2, value1.CompareTo(value2))
        Console.WriteLine()
        Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                          value1, value2, value1.CompareTo(value2))
    End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Questo metodo viene implementato per supportare l'interfaccia IComparable.

CompareTo(System.Single)

Questo metodo implementa l'interfaccia System.IComparable<T> ed esegue prestazioni leggermente migliori rispetto all'overload Single.CompareTo(Object) perché non è necessario convertire il parametro value in un oggetto .

using System;

public class Example2
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       float value2 = value1 * operand / operand;
       Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}");
       Console.WriteLine();
       Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = value1 * operand / operand
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example
   Public Sub Main()
       Dim value1 As Single = 16.5457
       Dim value2 As Single = value1 * CSng(3.8899982) / CSng(3.8899982)
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Conversioni di ampliamento

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 Single e che il tipo di parametro sia Int32. Il compilatore Microsoft C# genera istruzioni per rappresentare il valore del parametro come oggetto Single, quindi genera un metodo Single.CompareTo(Single) che confronta i valori dell'istanza e la rappresentazione estesa del parametro.

Consultare la documentazione del proprio linguaggio di programmazione per determinare se il compilatore esegue conversioni implicite di allargamento dei tipi numerici. Per altre informazioni, vedere l'argomento Tabelle di conversione dei tipi.

Precisione nelle comparazioni

La precisione dei numeri a virgola mobile al di là della precisione documentata dipende dall'implementazione e dalla versione di .NET. Di conseguenza, un confronto di due numeri particolari potrebbe cambiare tra le versioni di .NET perché la precisione della rappresentazione interna dei numeri potrebbe cambiare.

Vedi anche

Equals(Object)

Si applica a

CompareTo(Single)

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Origine:: Single.cs

Confronta questa istanza con un numero a virgola mobile e precisione singola specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero a virgola mobile a precisione singola specificato.

public:
 virtual int CompareTo(float value);

public int CompareTo(float value);

abstract member CompareTo : single -> int
override this.CompareTo : single -> int

Public Function CompareTo (value As Single) As Integer