System.Single.CompareTo-Methoden

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Werte müssen identisch sein, um gleich zu werden. Besonders wenn Gleitkommawerte von mehreren mathematischen Vorgängen abhängen, ist es üblich, dass sie genauigkeit verlieren und dass ihre Werte nahezu identisch sind, mit Ausnahme ihrer am wenigsten signifikanten Ziffern. Aus diesem Gründen kann der Rückgabewert der CompareTo Methode manchmal überraschend erscheinen. Beispielsweise sollte die Multiplikation durch einen bestimmten Wert, gefolgt von der Division durch denselben Wert, den ursprünglichen Wert erzeugen, im folgenden Beispiel wird der berechnete Wert jedoch größer als der ursprüngliche Wert. Wenn Alle signifikanten Ziffern der beiden Werte mithilfe der standardmäßigen numerischen Formatzeichenfolge "R" angezeigt werden, bedeutet dies, dass der berechnete Wert von dem ursprünglichen Wert in seinen am wenigsten signifikanten Ziffern abweicht. Informationen zum Behandeln solcher Vergleiche finden Sie im Abschnitt "Hinweise" der Equals(Single) Methode.

Obwohl ein Objekt, dessen Wert nicht gleich einem anderen Objekt ist NaNNaN , dessen Wert (auch selbst) ist, erfordert die IComparable<T> Schnittstelle, dass A.CompareTo(A) null zurückgegeben wird.

CompareTo(System.Object)

Der value Parameter muss null eine Instanz von Single; andernfalls wird eine Ausnahme ausgelöst. Jede Instanz von Single, unabhängig vom Wert, gilt als größer als 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

Diese Methode wird implementiert, um die IComparable Schnittstelle zu unterstützen.

CompareTo(System.Single)

Diese Methode implementiert die System.IComparable<T> Schnittstelle und führt etwas besser aus als die Single.CompareTo(Object) Überladung, da der value Parameter nicht in ein Objekt konvertiert werden muss.

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

Widening Conversions (Erweiterungskonvertierungen)

Je nach Programmiersprache kann es möglich sein, eine CompareTo Methode zu codieren, bei der der Parametertyp weniger Bits aufweist (ist schmaler) als der Instanztyp. Dies ist möglich, da einige Programmiersprachen eine implizite Erweiterungskonvertierung ausführen, die den Parameter als Typ mit so vielen Bits wie die Instanz darstellt.

Angenommen, der Instanztyp ist Single und der Parametertyp ist Int32. Der Microsoft C#-Compiler generiert Anweisungen, um den Wert des Parameters als Single Objekt darzustellen, und generiert dann eine Single.CompareTo(Single) Methode, die die Werte der Instanz und die erweiterte Darstellung des Parameters vergleicht.

In der Dokumentation der Programmiersprache können Sie ermitteln, ob der Compiler implizite Erweiterungskonvertierungen numerischer Typen durchführt. Weitere Informationen finden Sie im Thema "Typkonvertierungstabellen ".

Genauigkeit in Vergleichen

Die Genauigkeit von Gleitkommazahlen über die dokumentierte Genauigkeit hinaus ist spezifisch für die Implementierung und Version von .NET. Folglich kann sich ein Vergleich zweier bestimmter Zahlen zwischen .NET-Versionen ändern, da sich die Genauigkeit der internen Darstellung der Zahlen ändern kann.