Metody System.Single.CompareTo

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Hodnoty lze považovat za rovné pouze v případě, že jsou shodné. Zvláště když hodnoty s plovoucí desetinnou čárkou závisí na několika matematických operacích, je běžné, že ztratí přesnost a jejich hodnoty budou téměř stejné s výjimkou jejich nejméně významných číslic. Z tohoto důvodu se návratová CompareTo hodnota metody může někdy zdát překvapivá. Například násobení určitou hodnotou následovanou dělením stejnou hodnotou by mělo vytvořit původní hodnotu, ale v následujícím příkladu se vypočítaná hodnota zobrazí jako větší než původní hodnota. Zobrazení všech významných číslic dvou hodnot pomocí standardního řetězce číselného formátu "R" označuje, že vypočítaná hodnota se liší od původní hodnoty v nejméně významných číslicích. Informace o zpracování těchto porovnání naleznete v části Equals(Single) Poznámky metody.

I když objekt, jehož hodnota není NaN považována za rovnou jinému objektu, jehož hodnota je NaN (dokonce i samotná), IComparable<T> rozhraní vyžaduje, aby A.CompareTo(A) vrátilo nulu.

CompareTo(System.Object)

Parametr value musí být null nebo instance Single, jinak je vyvolán výjimka. Jakákoli instance Single, bez ohledu na jeho hodnotu, je považována za větší než 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

Tato metoda je implementována pro podporu IComparable rozhraní.

CompareTo(System.Single)

Tato metoda implementuje System.IComparable<T> rozhraní a provádí mírně lépe než Single.CompareTo(Object) přetížení, protože nemusí převést value parametr na objekt.

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

Rozšiřující převody

V závislosti na programovacím jazyce může být možné zakódovat metodu CompareTo , ve které má typ parametru méně bitů (je užší) než typ instance. Je to možné, protože některé programovací jazyky provádějí implicitní rozšiřující převod, který představuje parametr jako typ s tolika bity, kolik bitů má instance.

Předpokládejme například, že typ instance je Single a typ parametru je Int32. Kompilátor Jazyka Microsoft C# generuje instrukce představující hodnotu parametru jako Single objekt a pak vygeneruje Single.CompareTo(Single) metodu, která porovnává hodnoty instance a rozšířené reprezentace parametru.

Vyhledejte v dokumentaci k programovacímu jazyku, zda kompilátor provádí implicitní převody pro rozšíření číselných typů. Další informace naleznete v tématu Převodní tabulky typů.

Přesnost v porovnáních

Přesnost čísel s plovoucí desetinnou čárkou nad rámec zdokumentované přesnosti je specifická pro implementaci a verzi rozhraní .NET. V důsledku toho se může mezi verzemi .NET změnit porovnání dvou konkrétních čísel, protože se může změnit přesnost interní reprezentace čísel.