System.Double.CompareTo-Methoden

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

CompareTo(Double)-Methode

Werte müssen identisch sein, um gleich zu werden. Insbesondere wenn Gleitkommawerte von mehreren mathematischen Vorgängen abhängen, ist es üblich, dass sie genauigkeit verlieren und 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 division by the same value den ursprünglichen Wert erzeugen. Im folgenden Beispiel ist 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(Double) Methode.

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1
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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Double = value1 * .1 / .1
       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 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

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

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

CompareTo(Object)-Methode

Der value Parameter muss null eine Instanz von Double; andernfalls wird eine Ausnahme ausgelöst. Jede Instanz von Double, unabhängig vom Wert, gilt als größer als null.

Werte müssen identisch sein, um gleich zu werden. Insbesondere wenn Gleitkommawerte von mehreren mathematischen Vorgängen abhängen, ist es üblich, dass sie genauigkeit verlieren und 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 division by the same value den ursprünglichen Wert erzeugen. Im folgenden Beispiel ist 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(Double) Methode.

using System;

public class Example3
{
    public static void Main()
    {
        double value1 = 6.185;
        object value2 = value1 * .1 / .1;
        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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1 |> box
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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example2
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Object = value1 * .1 / .1
       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 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

Diese Methode wird implementiert, um die IComparable Schnittstelle zu unterstützen. Beachten Sie, dass eine NaN Schnittstelle zwar nicht als gleich einer anderen NaN (auch selbst) betrachtet wird, IComparable aber die Schnittstelle erfordert, dass A.CompareTo(A) null zurückgegeben wird.

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 Double und der Parametertyp ist Int32. Der Microsoft C#-Compiler generiert Anweisungen, um den Wert des Parameters als Double Objekt darzustellen, und generiert dann eine Double.CompareTo(Double) 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.