Metodi System.Single.CompareTo
Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.
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 CompareTo metodo 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. La visualizzazione di tutte le cifre significative dei due valori tramite 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 Equals(Single) metodo .
Anche se un oggetto il cui valore non è NaN considerato uguale a un altro oggetto il cui valore è NaN (anche se stesso), l'interfaccia IComparable<T> richiede che restituisca A.CompareTo(A) zero.
CompareTo(System.Object)
Il value parametro 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 {0} and {1}: {2}\n",
value1, value2, value1.CompareTo(value2));
Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
value1, value2, 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 leggermente meglio dell'overload Single.CompareTo(Object) perché non deve convertire il value parametro 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 {0} and {1}: {2}\n",
value1, value2, value1.CompareTo(value2));
Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
value1, value2, 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 estensione
A seconda del linguaggio di programmazione, potrebbe essere possibile codificare un CompareTo metodo 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 Single oggetto, quindi genera un Single.CompareTo(Single) metodo che confronta i valori dell'istanza e la rappresentazione estesa del parametro.
Consultare la documentazione del linguaggio di programmazione per determinare se il compilatore esegue conversioni implicite di tipi numerici verso l'ampliamento. Per altre informazioni, vedere l'argomento Tabelle di conversione dei tipi.
Precisione nei confronti
La precisione dei numeri a virgola mobile oltre la precisione documentata è specifica per l'implementazione e la 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.
