System.Single.CompareTo-methoden

Opmerking

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

Waarden moeten identiek zijn om als gelijk te worden beschouwd. Met name wanneer drijvendekommawaarden afhankelijk zijn van meerdere wiskundige bewerkingen, is het gebruikelijk dat ze precisie verliezen en dat hun waarden bijna identiek zijn, met uitzondering van hun minst significante cijfers. Hierdoor kan de retourwaarde van de CompareTo methode soms verrassend lijken. Vermenigvuldiging door een bepaalde waarde gevolgd door de verdeling door dezelfde waarde moet bijvoorbeeld de oorspronkelijke waarde opleveren, maar in het volgende voorbeeld blijkt de berekende waarde groter te zijn dan de oorspronkelijke waarde. Alle significante cijfers van de twee waarden weergeven met behulp van de standaardtekenreeks voor numerieke R-notatie geeft aan dat de berekende waarde verschilt van de oorspronkelijke waarde in de minst significante cijfers. Zie de sectie Opmerkingen van de Equals(Single) methode voor informatie over het verwerken van dergelijke vergelijkingen.

Hoewel een object waarvan de waarde NaN niet wordt beschouwd als gelijk aan een ander object waarvan de waarde (zelfs zelf) is NaN , vereist de IComparable<T> interface dat A.CompareTo(A) nul retourneert.

CompareTo(System.Object)

De value-parameter moet null zijn of een instantie van Single, anders wordt er een uitzondering opgeworpen. Elk exemplaar van Single, ongeacht de waarde, wordt beschouwd als groter dan 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

Deze methode wordt geïmplementeerd ter ondersteuning van de IComparable interface.

CompareTo(System.Single)

Deze methode implementeert de System.IComparable<T> interface en presteert iets beter dan de Single.CompareTo(Object) overbelasting omdat de value parameter niet hoeft te worden geconverteerd naar een object.

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

Conversies breder maken

Afhankelijk van uw programmeertaal is het mogelijk om een CompareTo methode te codeeren waarbij het parametertype minder bits heeft (is smaller) dan het exemplaartype. Dit is mogelijk omdat sommige programmeertalen een impliciete widening conversie uitvoeren die de parameter vertegenwoordigt als een type met zoveel bits als het exemplaar.

Stel dat het exemplaartype is Single en het parametertype is Int32. De Microsoft C#-compiler genereert instructies voor het weergeven van de waarde van de parameter als een Single object en genereert vervolgens een Single.CompareTo(Single) methode waarmee de waarden van het exemplaar en de uitgebreide weergave van de parameter worden vergeleken.

Raadpleeg de documentatie van uw programmeertaal om te bepalen of de compiler impliciete widening conversies van numerieke typen uitvoert. Zie het onderwerp Type conversietabellen voor meer informatie.

Precisie in vergelijkingen

De nauwkeurigheid van drijvendekommagetallen voorbij de gedocumenteerde precisie is afhankelijk van de implementatie en versie van .NET. Een vergelijking van twee bepaalde getallen kan dus veranderen tussen versies van .NET, omdat de precisie van de interne weergave van de getallen kan veranderen.