System.Single.CompareTo-metoder

Anmärkning

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

Värdena måste vara identiska för att anses vara lika. Särskilt när flyttalsvärden är beroende av flera matematiska operationer är det vanligt att de förlorar precision och att deras värden är nästan identiska förutom de minst signifikanta siffrorna. Därför kan returvärdet för metoden CompareTo verka överraskande ibland. Till exempel bör multiplikation med ett visst värde följt av division med samma värde generera det ursprungliga värdet, men i följande exempel visar sig det beräknade värdet vara större än det ursprungliga värdet. Om du visar alla signifikanta siffror i de två värdena med hjälp av "R" standardsträng i numeriskt format anger att det beräknade värdet skiljer sig från det ursprungliga värdet i dess minst signifikanta siffror. Information om hur du hanterar sådana jämförelser finns i avsnittet Anmärkningar i metoden Equals(Single).

Även om ett objekt vars värde är NaN inte anses vara lika med ett annat objekt vars värde är NaN (även sig själv), kräver IComparable<T> gränssnitt att A.CompareTo(A) returnera noll.

CompareTo(System.Object)

Parametern value måste vara null eller en instans av Single. annars utlöses ett undantag. Alla instanser av Single, oavsett dess värde, anses vara större än 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

Den här metoden implementeras för att stödja IComparable-gränssnittet.

CompareTo(System.Single)

Den här metoden implementerar System.IComparable<T>-gränssnittet och presterar något bättre än den Single.CompareTo(Object) överlagringen eftersom den inte behöver konvertera parametern value till ett 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 {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

Bredda konverteringar

Beroende på programmeringsspråket kan det vara möjligt att koda en CompareTo metod där parametertypen har färre bitar (är smalare) än instanstypen. Detta är möjligt eftersom vissa programmeringsspråk utför en implicit breddningskonvertering som representerar parametern som en typ med så många bitar som instansen.

Anta till exempel att instanstypen är Single och att parametertypen är Int32. Microsoft C#-kompilatorn genererar instruktioner för att representera värdet för parametern som ett Single-objekt och genererar sedan en Single.CompareTo(Single)-metod som jämför instansens värden och den vidgade representationen av parametern.

Läs dokumentationen för programmeringsspråket för att avgöra om kompilatorn utför implicita breddningskonverteringar av numeriska typer. För mer information, se avsnittet Typkonverteringstabeller.

Precision i jämförelser

Precisionen för flyttalsnummer utöver den dokumenterade precisionen är specifik för implementeringen och versionen av .NET. Därför kan en jämförelse av två specifika tal ändras mellan versioner av .NET eftersom precisionen i talens interna representation kan ändras.