Single Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine Gleitkommazahl mit einfacher Genauigkeit dar.

public value class float : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, System::Numerics::IAdditionOperators<float, float, float>, System::Numerics::IAdditiveIdentity<float, float>, System::Numerics::IBinaryFloatingPointIeee754<float>, System::Numerics::IBinaryNumber<float>, System::Numerics::IBitwiseOperators<float, float, float>, System::Numerics::IComparisonOperators<float, float, bool>, System::Numerics::IDecrementOperators<float>, System::Numerics::IDivisionOperators<float, float, float>, System::Numerics::IEqualityOperators<float, float, bool>, System::Numerics::IExponentialFunctions<float>, System::Numerics::IFloatingPoint<float>, System::Numerics::IFloatingPointConstants<float>, System::Numerics::IFloatingPointIeee754<float>, System::Numerics::IHyperbolicFunctions<float>, System::Numerics::IIncrementOperators<float>, System::Numerics::ILogarithmicFunctions<float>, System::Numerics::IMinMaxValue<float>, System::Numerics::IModulusOperators<float, float, float>, System::Numerics::IMultiplicativeIdentity<float, float>, System::Numerics::IMultiplyOperators<float, float, float>, System::Numerics::INumber<float>, System::Numerics::INumberBase<float>, System::Numerics::IPowerFunctions<float>, System::Numerics::IRootFunctions<float>, System::Numerics::ISignedNumber<float>, System::Numerics::ISubtractionOperators<float, float, float>, System::Numerics::ITrigonometricFunctions<float>, System::Numerics::IUnaryNegationOperators<float, float>, System::Numerics::IUnaryPlusOperators<float, float>

public readonly struct Single : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, System.Numerics.IAdditionOperators<float,float,float>, System.Numerics.IAdditiveIdentity<float,float>, System.Numerics.IBinaryFloatingPointIeee754<float>, System.Numerics.IBinaryNumber<float>, System.Numerics.IBitwiseOperators<float,float,float>, System.Numerics.IComparisonOperators<float,float,bool>, System.Numerics.IDecrementOperators<float>, System.Numerics.IDivisionOperators<float,float,float>, System.Numerics.IEqualityOperators<float,float,bool>, System.Numerics.IExponentialFunctions<float>, System.Numerics.IFloatingPoint<float>, System.Numerics.IFloatingPointConstants<float>, System.Numerics.IFloatingPointIeee754<float>, System.Numerics.IHyperbolicFunctions<float>, System.Numerics.IIncrementOperators<float>, System.Numerics.ILogarithmicFunctions<float>, System.Numerics.IMinMaxValue<float>, System.Numerics.IModulusOperators<float,float,float>, System.Numerics.IMultiplicativeIdentity<float,float>, System.Numerics.IMultiplyOperators<float,float,float>, System.Numerics.INumber<float>, System.Numerics.INumberBase<float>, System.Numerics.IPowerFunctions<float>, System.Numerics.IRootFunctions<float>, System.Numerics.ISignedNumber<float>, System.Numerics.ISubtractionOperators<float,float,float>, System.Numerics.ITrigonometricFunctions<float>, System.Numerics.IUnaryNegationOperators<float,float>, System.Numerics.IUnaryPlusOperators<float,float>

type single = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<single>
    interface ISpanFormattable
    interface ISpanParsable<single>
    interface IAdditionOperators<single, single, single>
    interface IAdditiveIdentity<single, single>
    interface IBinaryFloatingPointIeee754<single>
    interface IBinaryNumber<single>
    interface IBitwiseOperators<single, single, single>
    interface IComparisonOperators<single, single, bool>
    interface IEqualityOperators<single, single, bool>
    interface IDecrementOperators<single>
    interface IDivisionOperators<single, single, single>
    interface IIncrementOperators<single>
    interface IModulusOperators<single, single, single>
    interface IMultiplicativeIdentity<single, single>
    interface IMultiplyOperators<single, single, single>
    interface INumber<single>
    interface INumberBase<single>
    interface ISubtractionOperators<single, single, single>
    interface IUnaryNegationOperators<single, single>
    interface IUnaryPlusOperators<single, single>
    interface IExponentialFunctions<single>
    interface IFloatingPointConstants<single>
    interface IFloatingPoint<single>
    interface ISignedNumber<single>
    interface IFloatingPointIeee754<single>
    interface IHyperbolicFunctions<single>
    interface ILogarithmicFunctions<single>
    interface IPowerFunctions<single>
    interface IRootFunctions<single>
    interface ITrigonometricFunctions<single>
    interface IMinMaxValue<single>

Public Structure Single
Implements IAdditionOperators(Of Single, Single, Single), IAdditiveIdentity(Of Single, Single), IBinaryFloatingPointIeee754(Of Single), IBinaryNumber(Of Single), IBitwiseOperators(Of Single, Single, Single), IComparable(Of Single), IComparisonOperators(Of Single, Single, Boolean), IConvertible, IDecrementOperators(Of Single), IDivisionOperators(Of Single, Single, Single), IEqualityOperators(Of Single, Single, Boolean), IEquatable(Of Single), IExponentialFunctions(Of Single), IFloatingPoint(Of Single), IFloatingPointConstants(Of Single), IFloatingPointIeee754(Of Single), IHyperbolicFunctions(Of Single), IIncrementOperators(Of Single), ILogarithmicFunctions(Of Single), IMinMaxValue(Of Single), IModulusOperators(Of Single, Single, Single), IMultiplicativeIdentity(Of Single, Single), IMultiplyOperators(Of Single, Single, Single), INumber(Of Single), INumberBase(Of Single), IParsable(Of Single), IPowerFunctions(Of Single), IRootFunctions(Of Single), ISignedNumber(Of Single), ISpanParsable(Of Single), ISubtractionOperators(Of Single, Single, Single), ITrigonometricFunctions(Of Single), IUnaryNegationOperators(Of Single, Single), IUnaryPlusOperators(Of Single, Single)

Vererbung

Object

ValueType

Single

Implementiert

IComparable IComparable<Single> IConvertible IEquatable<Single> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Single> IParsable<TSelf> ISpanParsable<Single> ISpanParsable<TSelf> IAdditionOperators<Single,Single,Single> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Single,Single> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Single> IBinaryNumber<Single> IBinaryNumber<TSelf> IBitwiseOperators<Single,Single,Single> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Single,Single,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Single> IDecrementOperators<TSelf> IDivisionOperators<Single,Single,Single> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Single,Single,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Single> IExponentialFunctions<TSelf> IFloatingPoint<Single> IFloatingPoint<TSelf> IFloatingPointConstants<Single> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Single> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Single> IHyperbolicFunctions<TSelf> IIncrementOperators<Single> IIncrementOperators<TSelf> ILogarithmicFunctions<Single> ILogarithmicFunctions<TSelf> IMinMaxValue<Single> IModulusOperators<Single,Single,Single> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Single,Single> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Single,Single,Single> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Single> INumber<TSelf> INumberBase<Single> INumberBase<TSelf> IPowerFunctions<Single> IPowerFunctions<TSelf> IRootFunctions<Single> IRootFunctions<TSelf> ISignedNumber<Single> ISignedNumber<TSelf> ISubtractionOperators<Single,Single,Single> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Single> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Single,Single> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Single,Single> IUnaryPlusOperators<TSelf,TSelf>

Hinweise

Der Single Werttyp stellt eine 32-Bit-Zahl mit einer einzigen Genauigkeit dar, deren Werte von negativer 3.402823e38 bis positiver 3.402823e38 sowie positiver oder negativer Nullwert, PositiveInfinity, , NegativeInfinityund nicht einer Zahl (NaN) reichen. Sie soll Werte darstellen, die extrem groß (z. B. Entfernungen zwischen Planeten oder Galaxien) oder extrem klein (z. B. die Molekularmasse einer Substanz in Kilogramm) und oft ungenau sind (z. B. die Entfernung von der Erde zu einem anderen Sonnensystem). Der Single Typ entspricht der NORM IEC 60559:1989 (IEEE 754) für binäre Gleitkommaarithmetik.

Dieser Artikel besteht aus den folgenden Abschnitten:

• Gleitkommadarstellung und Genauigkeit

• Testen auf Gleichheit

• Gleitkommawerte und Ausnahmen

• Typkonvertierung und einzelne Struktur

• Gleitkommafunktionalität

System.Singlestellt Methoden bereit, um Instanzen dieses Typs zu vergleichen, den Wert eines instance in seine Zeichenfolgendarstellung zu konvertieren und die Zeichenfolgendarstellung einer Zahl in eine instance dieses Typs zu konvertieren. Informationen dazu, wie Formatspezifikationscodes die Zeichenfolgendarstellung von Werttypen steuern, finden Sie unter Formatierungstypen, Numerische Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.

Gleitkommadarstellung und Genauigkeit

Der Single Datentyp speichert Gleitkommawerte mit einzeler Genauigkeit in einem 32-Bit-Binärformat, wie in der folgenden Tabelle gezeigt:

Teil	Bits
Significand oder Mantissa	0-22
Exponent	23-30
Vorzeichen (0 = positiv, 1 = negativ)	31

So wie Dezimalbrüche einige Bruchwerte (z. B. 1/3 oder Math.PI) nicht präzise darstellen können, können binäre Brüche einige Bruchwerte nicht darstellen. Beispielsweise wird 2/10, das genau durch .2 als Dezimalbruch dargestellt wird, durch .0011111001001100 als binäre Fraktion dargestellt, wobei sich das Muster "1100" bis unendlich wiederholt. In diesem Fall bietet der Gleitkommawert eine ungenaue Darstellung der Zahl, die er darstellt. Das Ausführen zusätzlicher mathematischer Vorgänge für den ursprünglichen Gleitkommawert erhöht häufig die fehlende Genauigkeit. Wenn Sie beispielsweise die Ergebnisse der Multiplikation von .3 mit 10 vergleichen und neunmal .3 zu .3 hinzufügen, sehen Sie, dass die Addition das weniger präzise Ergebnis erzeugt, da sie acht weitere Vorgänge als die Multiplikation umfasst. Beachten Sie, dass diese Ungleichheit nur sichtbar ist, wenn Sie die beiden Single Werte mithilfe der numerischen Standardformatzeichenfolge "R" anzeigen, die bei Bedarf alle vom Typ unterstützten 9 Ziffern der Single Genauigkeit anzeigt.

using System;

public class Example
{
   public static void Main()
   {
      Single value = .2f;
      Single result1 = value * 10f;
      Single result2 = 0f;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

let value = 0.2f
let result1 = value * 10f
let mutable result2 = 0f
for _ = 1 to 10 do
    result2 <- result2 + value

printfn $".2 * 10:           {result1:R}"
printfn $".2 Added 10 times: {result2:R}"
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

Module Example
   Public Sub Main()
      Dim value As Single = .2
      Dim result1 As Single = value * 10
      Dim result2 As Single
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".2 * 10:           {0:R}", result1)
      Console.WriteLine(".2 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

Da einige Zahlen nicht genau als Bruchbinärwerte dargestellt werden können, können Gleitkommazahlen nur annähernd reelle Zahlen darstellen.

Alle Gleitkommazahlen weisen eine begrenzte Anzahl signifikanter Ziffern auf, was auch bestimmt, wie genau ein Gleitkommawert einer reellen Zahl annähert. Ein Single Wert weist eine Genauigkeit von bis zu 7 Dezimalstellen auf, obwohl maximal 9 Ziffern intern beibehalten werden. Dies bedeutet, dass bei einigen Gleitkommavorgängen möglicherweise die Genauigkeit fehlt, um einen Gleitkommawert zu ändern. Im folgenden Beispiel wird ein großer Gleitkommawert mit nur einer Genauigkeit definiert und anschließend das Produkt und Single.Epsilon eine Billiarde hinzugefügt. Das Produkt ist jedoch zu klein, um den ursprünglichen Gleitkommawert zu ändern. Die geringste Zahl ist Tausendstel, während die wichtigste Ziffer im Produkt ^10-30 ist.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123.456f;
      Single additional = Single.Epsilon * 1e15f;
      Console.WriteLine($"{value} + {additional} = {value + additional}");
   }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

open System

let value = 123.456f
let additional = Single.Epsilon * 1e15f
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

Die begrenzte Genauigkeit einer Gleitkommazahl hat mehrere Folgen:

• Zwei Gleitkommazahlen, die für eine bestimmte Genauigkeit identisch zu sein scheinen, können sich als unterschiedlich erweisen, wenn sich die zwei letzten Ziffern unterscheiden. Im folgenden Beispiel wird eine Reihe von Zahlen addiert, und ihre Summe wird mit der erwarteten Summe verglichen. Obwohl die beiden Werte identisch zu sein scheinen, gibt ein Aufruf der Equals -Methode an, dass sie nicht sind.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
        Single result = 27.65f;
        Single total = 0f;
        foreach (var value in values)
           total += value;
  
        if (total.Equals(result))
           Console.WriteLine("The sum of the values equals the total.");
        else
           Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                             total, result); 
     }
  }
  // The example displays the following output:
  //      The sum of the values (27.65) does not equal the total (27.65).   
  //
  // If the index items in the Console.WriteLine statement are changed to {0:R},
  // the example displays the following output:
  //       The sum of the values (27.6500015) does not equal the total (27.65).
  

  let values = [| 10.01f; 2.88f; 2.88f; 2.88f; 9f |]
  let result = 27.65f
  let mutable total = 0f
  for value in values do
      total <- total + value
  
  if total.Equals result then
      printfn "The sum of the values equals the total."
  else
      printfn "The sum of the values ({total}) does not equal the total ({result})."
  // The example displays the following output:
  //      The sum of the values (27.65) does not equal the total (27.65).   
  //
  // If the index items in the Console.WriteLine statement are changed to {0:R},
  // the example displays the following output:
  //       The sum of the values (27.6500015) does not equal the total (27.65).
  

  Module Example
     Public Sub Main()
        Dim values() As Single = { 10.01, 2.88, 2.88, 2.88, 9.0 }
        Dim result As Single = 27.65
        Dim total As Single
        For Each value In values
           total += value
        Next
        If total.Equals(result) Then
           Console.WriteLine("The sum of the values equals the total.")
        Else
           Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                             total, result) 
        End If     
     End Sub
  End Module
  ' The example displays the following output:
  '      The sum of the values (27.65) does not equal the total (27.65).   
  '
  ' If the index items in the Console.WriteLine statement are changed to {0:R},
  ' the example displays the following output:
  '       The sum of the values (27.639999999999997) does not equal the total (27.64).
  

  Wenn Sie die Formatelemente in der Console.WriteLine(String, Object, Object) Anweisung von {0} und {1} in {0:R} ändern und {1:R} alle wichtigen Ziffern der beiden Single Werte anzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeitsverlusts während der Additionsvorgänge ungleich sind. In diesem Fall kann das Problem behoben werden, indem die Math.Round(Double, Int32) -Methode aufgerufen wird, um die Single Werte vor dem Vergleich auf die gewünschte Genauigkeit zu runden.

• Ein mathematischer Oder Vergleichsvorgang, der eine Gleitkommazahl verwendet, liefert möglicherweise nicht das gleiche Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht der Dezimalzahl entspricht. In einem vorherigen Beispiel wurde dies veranschaulicht, indem das Ergebnis der Multiplikation von .3 mit 10 und neunmal das Hinzufügen von .3 zu .3 angezeigt wurde.

  Wenn die Genauigkeit in numerischen Vorgängen mit Bruchwerten wichtig ist, verwenden Sie anstelle des Typs den DecimalSingle Typ. Wenn genauigkeit in numerischen Vorgängen mit integralen Werten außerhalb des Bereichs der Int64 Typen oder UInt64 wichtig ist, verwenden Sie den BigInteger Typ.

• Ein Wert ist möglicherweise nicht roundtrip, wenn eine Gleitkommazahl betroffen ist. Ein Wert wird als Roundtrip bezeichnet, wenn ein Vorgang eine ursprüngliche Gleitkommazahl in eine andere Form konvertiert, ein umgekehrter Vorgang das konvertierte Formular wieder in eine Gleitkommazahl transformiert und die letzte Gleitkommazahl gleich der ursprünglichen Gleitkommazahl ist. Die Rundreise schlägt möglicherweise fehl, weil eine oder mehrere wichtige Ziffern verloren gehen oder bei einer Konvertierung geändert werden. Im folgenden Beispiel werden drei Single Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert. Wie die Ausgabe zeigt, sind die Werte zwar identisch, aber die wiederhergestellten Werte entsprechen nicht den ursprünglichen Werten.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\Singles.dat");
        Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++) {
           sw.Write(values[ctr].ToString());
           if (ctr != values.Length - 1)
              sw.Write("|");
        }      
        sw.Close();
        
        Single[] restoredValues = new Single[values.Length];
        StreamReader sr = new StreamReader(@".\Singles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
           restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
  
        for (int ctr = 0; ctr < values.Length; ctr++)
           Console.WriteLine("{0} {2} {1}", values[ctr], 
                             restoredValues[ctr],
                             values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
     }
  }
  // The example displays the following output:
  //       2.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write(string values[i])
          if i <> values.Length - 1 then
              sw.Write "|"
  
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  for i = 0 to values.Length - 1 do
      printfn $"""{values[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}"""
                      
  // The example displays the following output:
  //       2.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Singles.dat")
        Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write(values(ctr).ToString())
           If ctr <> values.Length - 1 Then sw.Write("|")
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Single
        Dim sr As New StreamReader(".\Singles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '        2.882883 <> 2.882883
  '        0.3333333 <> 0.3333333
  '        3.141593 <> 3.141593
  

  In diesem Fall können die Werte erfolgreich gerundet werden, indem die numerische Standardformatzeichenfolge "G9" verwendet wird, um die volle Genauigkeit der Single Werte beizubehalten, wie im folgenden Beispiel gezeigt.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\Singles.dat");
        Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++) 
           sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
        
        sw.Close();
        
        Single[] restoredValues = new Single[values.Length];
        StreamReader sr = new StreamReader(@".\Singles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
           restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
  
        for (int ctr = 0; ctr < values.Length; ctr++)
           Console.WriteLine("{0} {2} {1}", values[ctr], 
                             restoredValues[ctr],
                             values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
     }
  }
  // The example displays the following output:
  //       2.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write $"""{values[i]:G9}{if i < values.Length - 1 then "|" else ""}"""
      
      
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  for i = 0 to values.Length - 1 do
      printfn $"""{values[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}"""
  // The example displays the following output:
  //       2.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Singles.dat")
        Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write("{0:G9}{1}", values(ctr), 
                    If(ctr < values.Length - 1, "|", ""))
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Single
        Dim sr As New StreamReader(".\Singles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.882883 = 2.882883
  '       0.3333333 = 0.3333333
  '       3.141593 = 3.141593
  

• Single Werte haben eine geringere Genauigkeit als Double Werte. Ein Single Wert, der in einen scheinbar gleichwertigen Double Wert konvertiert wird, entspricht oft aufgrund von Genauigkeitsunterschieden nicht dem Double Wert. Im folgenden Beispiel wird das Ergebnis identischer Divisionsvorgänge einem Double Wert und einem Single Wert zugewiesen. Nachdem der Single Wert in ein Doubleumgewandelt wurde, zeigt ein Vergleich der beiden Werte, dass sie ungleich sind.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Double value1 = 1/3.0;
        Single sValue2 = 1/3.0f;
        Double value2 = (Double) sValue2;
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                                            value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  open System
  
  let value1 = 1. / 3.
  let sValue2 = 1f /3f
  
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1/3
        Dim sValue2 As Single = 1/3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

  Um dieses Problem zu vermeiden, verwenden Sie entweder den Double Datentyp anstelle des Single Datentyps, oder verwenden Sie die Round -Methode, damit beide Werte die gleiche Genauigkeit aufweisen.

Testen auf Gleichheit

Um als gleich angesehen zu werden, müssen zwei Single Werte identische Werte darstellen. Aufgrund von Genauigkeitsunterschieden zwischen Werten oder aufgrund eines Genauigkeitsverlusts um einen oder beide Werte erweisen sich Gleitkommawerte, von denen erwartet wird, dass sie identisch sind, häufig aufgrund von Unterschieden in ihren am wenigsten signifikanten Ziffern ungleich. Daher führen Aufrufe der Equals -Methode, um zu bestimmen, ob zwei Werte gleich sind, oder Aufrufe der CompareTo -Methode, um die Beziehung zwischen zwei Single Werten zu bestimmen, oft zu unerwarteten Ergebnissen. Dies wird im folgenden Beispiel deutlich, in dem sich zwei scheinbar gleiche Single Werte als ungleich erweisen, da der erste Wert eine Genauigkeit von 7 Ziffern aufweist, während der zweite Wert 9 aufweist.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

let value1 = 0.3333333f
let value2 = 1f / 3f
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.3333333 = 0.333333343: False

Module Example
   Public Sub Main()
      Dim value1 As Single = .3333333
      Dim value2 As Single = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

Berechnete Werte, die unterschiedlichen Codepfaden folgen und auf unterschiedliche Weise bearbeitet werden, erweisen sich häufig als ungleich. Im folgenden Beispiel ist ein Single Wert quadratisch, und dann wird die Quadratwurzel berechnet, um den ursprünglichen Wert wiederherzustellen. Eine Sekunde Single wird mit 3,51 multipliziert und im Quadrat angegeben, bevor die Quadratwurzel des Ergebnisses durch 3,51 geteilt wird, um den ursprünglichen Wert wiederherzustellen. Obwohl die beiden Werte identisch zu sein scheinen, gibt ein Aufruf der Equals(Single) -Methode an, dass sie nicht gleich sind. Wenn Sie die Standardformatzeichenfolge "G9" verwenden, um eine Ergebniszeichenfolge zurückzugeben, die alle wichtigen Ziffern jedes Single Werts anzeigt, wird angezeigt, dass der zweite Wert .0000000000001 kleiner als der erste ist.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

let value1 = 
    10.201438f ** 2f
    |> sqrt

let value2 =
   ((value1 * 3.51f) ** 2f |> sqrt) / 3.51f

printfn $"{value1} = {value2}: {value1.Equals value2}\n" 
printfn $"{value1:G9} = {value2:G9}"
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Module Example
   Public Sub Main()
      Dim value1 As Single = 10.201438
      value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
      Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
      value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

In Fällen, in denen sich ein Genauigkeitsverlust wahrscheinlich auf das Ergebnis eines Vergleichs auswirkt, können Sie die folgenden Techniken verwenden, anstatt die Equals -Methode oder CompareTo aufzurufen:

• Rufen Sie die Math.Round -Methode auf, um sicherzustellen, dass beide Werte die gleiche Genauigkeit aufweisen. Im folgenden Beispiel wird ein vorheriges Beispiel so geändert, dass dieser Ansatz verwendet wird, sodass zwei Bruchwerte gleichwertig sind.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = .3333333f;
        float value2 = 1.0f/3;
        int precision = 7;
        value1 = (float) Math.Round(value1, precision);
        value2 = (float) Math.Round(value2, precision);
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  open System
  
  let value1 = 0.3333333f
  let value2 = 1f / 3f
  let precision = 7
  let value1r = Math.Round(float value1, precision) |> float32
  let value2r = Math.Round(float value2, precision) |> float32
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = .3333333
        Dim value2 As Single = 1/3
        Dim precision As Integer = 7
        value1 = CSng(Math.Round(value1, precision))
        value2 = CSng(Math.Round(value2, precision))
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  Das Problem der Genauigkeit gilt weiterhin für die Rundung von Mittelpunktwerten. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).

• Testen Sie die ungefähre Gleichheit anstelle der Gleichheit. Dieses Verfahren erfordert, dass Sie entweder einen absoluten Betrag definieren, um den sich die beiden Werte unterscheiden können, aber dennoch gleich sein können, oder dass Sie einen relativen Betrag definieren, um den der kleinere Wert vom größeren Wert abweichen kann.

  Warnung

  Single.Epsilon wird manchmal als absolutes Maß für den Abstand zwischen zwei Single Werten verwendet, wenn auf Gleichheit getestet wird. Misst jedoch den kleinstmöglichen Wert, Single.Epsilon der einem hinzugefügt oder subtrahiert werden kann, Single dessen Wert 0 ist. Für die meisten positiven und negativen Single Werte ist der Wert von Single.Epsilon zu klein, um erkannt zu werden. Daher wird mit Ausnahme von Werten, die null sind, die Verwendung in Tests auf Gleichheit abgeraten.

  Im folgenden Beispiel wird der letztere Ansatz verwendet, um eine IsApproximatelyEqual Methode zu definieren, die den relativen Unterschied zwischen zwei Werten testet. Außerdem wird das Ergebnis von Aufrufen der IsApproximatelyEqual -Methode und der Equals(Single) -Methode kontrastiert.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float one1 = .1f * 10;
        float one2 = 0f;
        for (int ctr = 1; ctr <= 10; ctr++)
           one2 += .1f;
  
        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                          one1, one2, 
                          IsApproximatelyEqual(one1, one2, .000001f));   
     }
  
     static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
     {
        // If they are equal anyway, just return True.
        if (value1.Equals(value2))
           return true;
  
        // Handle NaN, Infinity.
        if (Double.IsInfinity(value1) | Double.IsNaN(value1))
           return value1.Equals(value2);
        else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
           return value1.Equals(value2);
  
        // Handle zero to avoid division by zero
        double divisor = Math.Max(value1, value2);
        if (divisor.Equals(0)) 
           divisor = Math.Min(value1, value2);
        
        return Math.Abs(value1 - value2)/divisor <= epsilon;           
     } 
  }
  // The example displays the following output:
  //       1 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  open System
  
  let isApproximatelyEqual value1 value2 epsilon =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      // Handle NaN, Infinity.
      elif Single.IsInfinity value1 || Single.IsNaN value1 then
          value1.Equals value2
      elif Single.IsInfinity value2 || Single.IsNaN value2 then
          value1.Equals value2
      else
          // Handle zero to avoid division by zero
          let divisor = max value1 value2
          let divisor = 
              if divisor.Equals 0 then
                  min value1 value2
              else divisor
          abs (value1 - value2) / divisor <= epsilon           
  
  
  let one1 = 0.1f * 10f
  let mutable one2 = 0f
  for _ = 1 to 10 do
     one2 <- one2 + 0.1f
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000001f}" 
  // The example displays the following output:
  //       1 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  Module Example
     Public Sub Main()
        Dim one1 As Single = .1 * 10
        Dim one2 As Single = 0
        For ctr As Integer = 1 To 10
           one2 += CSng(.1)
        Next
        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                          one1, one2, 
                          IsApproximatelyEqual(one1, one2, .000001))   
     End Sub
  
     Function IsApproximatelyEqual(value1 As Single, value2 As Single, 
                                   epsilon As Single) As Boolean
        ' If they are equal anyway, just return True.
        If value1.Equals(value2) Then Return True
        
        ' Handle NaN, Infinity.
        If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
           Return value1.Equals(value2)
        Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
           Return value1.Equals(value2)
        End If
        
        ' Handle zero to avoid division by zero
        Dim divisor As Single = Math.Max(value1, value2)
        If divisor.Equals(0) Then
           divisor = Math.Min(value1, value2)
        End If 
        
        Return Math.Abs(value1 - value2)/divisor <= epsilon           
     End Function
  End Module
  ' The example displays the following output:
  '       1 = 1.00000012: False
  '       1 is approximately equal to 1.00000012: True
  

Gleitkommawerte und Ausnahmen

Vorgänge mit Gleitkommawerten lösen keine Ausnahmen aus, im Gegensatz zu Vorgängen mit integralen Typen, die Ausnahmen in Fällen illegaler Vorgänge auslösen, z. B. division by zero oder overflow. Stattdessen ist das Ergebnis eines Gleitkommavorgangs in diesen Situationen Null, positive Unendlichkeit, negative Unendlichkeit oder keine Zahl (NaN):

• Wenn das Ergebnis eines Gleitkommavorgangs für das Zielformat zu klein ist, ist das Ergebnis 0. Dies kann auftreten, wenn zwei sehr kleine Gleitkommazahlen multipliziert werden, wie das folgende Beispiel zeigt.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = 1.163287e-36f;
        float value2 = 9.164234e-25f;
        float result = value1 * value2;
        Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
     }
  }
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  let value1 = 1.163287e-36f
  let value2 = 9.164234e-25f
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals(0f)}"
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = 1.163287e-36
        Dim value2 As Single = 9.164234e-25
        Dim result As Single = value1 * value2
        Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
     End Sub
  End Module
  ' The example displays the following output:
  '       1.163287E-36 * 9.164234E-25 = 0
  '       0 = 0: True
  

• Wenn die Größe des Ergebnisses eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, ist PositiveInfinity das Ergebnis des Vorgangs oder NegativeInfinity, wie für das Vorzeichen des Ergebnisses geeignet. Das Ergebnis eines überlaufenen Vorgangs Single.MaxValue ist PositiveInfinity, und das Ergebnis eines Vorgangs Single.MinValue , der überläuft, ist NegativeInfinity, wie das folgende Beispiel zeigt.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        float value1 = 3.065e35f;
        float value2 = 6.9375e32f;
        float result = value1 * value2;
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}\n", 
                          Single.IsNegativeInfinity(result));
  
        value1 = -value1;
        result = value1 * value2;
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result));
     }
  }                                                                 
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  open System
  
  let value1 = 3.065e35f
  let value2 = 6.9375e32f
  let result = value1 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}\n"
  
  let value3 = -value1
  let result2 = value3 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}" 
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Single = 3.065e35
        Dim value2 As Single = 6.9375e32
        Dim result As Single = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result))
        Console.WriteLine()                  
        value1 = -value1
        result = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Single.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Single.IsNegativeInfinity(result))
     End Sub
  End Module
  ' The example displays the following output:
  '       PositiveInfinity: True
  '       NegativeInfinity: False
  '       
  '       PositiveInfinity: False
  '       NegativeInfinity: True
  

  PositiveInfinity ergibt sich auch aus einer Division um 0 mit einer positiven Dividende und NegativeInfinity aus einer Division um 0 mit einer negativen Dividende.

• Wenn ein Gleitkommavorgang ungültig ist, ist NaNdas Ergebnis des Vorgangs . Beispiel: NaN Ergebnisse aus den folgenden Vorgängen:

  • Division durch Null mit einer Dividende von 0. Beachten Sie, dass andere Fälle der Teilung durch 0 entweder PositiveInfinity oder führen NegativeInfinity.

  • Jeder Gleitkommavorgang mit ungültiger Eingabe. Wenn Sie beispielsweise versuchen, die Quadratwurzel eines negativen Werts zu finden, wird zurückgegeben NaN.

  • Jeder Vorgang mit einem Argument, dessen Wert ist Single.NaN.

Typkonvertierungen und die einzelne Struktur

Die Single Struktur definiert keine expliziten oder impliziten Konvertierungsoperatoren. Stattdessen werden Konvertierungen vom Compiler implementiert.

In der folgenden Tabelle sind die möglichen Konvertierungen eines Werts der anderen primitiven numerischen Typen in einen Single Wert aufgeführt. Außerdem wird angegeben, ob die Konvertierung erweitert oder eingeschränkt wird und ob der resultierende Single Wert möglicherweise eine geringere Genauigkeit als der ursprüngliche Wert aufweist.

Konvertierung von	Verbreiterung/Verengung	Möglicher Genauigkeitsverlust
Byte	Widening	Nein
Decimal	Widening Beachten Sie, dass für C# ein Umwandlungsoperator erforderlich ist.	Ja. Decimal unterstützt 29 Dezimalstellen der Genauigkeit; Single unterstützt 9.
Double	Verengung; Out-of-Range-Werte werden in Double.NegativeInfinity oder Double.PositiveInfinitykonvertiert.	Ja. Double unterstützt 17 Dezimalstellen der Genauigkeit; Single unterstützt 9.
Int16	Widening	Nein
Int32	Widening	Ja. Int32 unterstützt 10 Dezimalstellen der Genauigkeit; Single unterstützt 9.
Int64	Widening	Ja. Int64 unterstützt 19 Dezimalstellen der Genauigkeit; Single unterstützt 9.
SByte	Widening	Nein
UInt16	Widening	Nein
UInt32	Widening	Ja. UInt32 unterstützt 10 Dezimalstellen der Genauigkeit; Single unterstützt 9.
UInt64	Widening	Ja. Int64 unterstützt 20 Dezimalstellen der Genauigkeit; Single unterstützt 9.

Im folgenden Beispiel wird der Mindest- oder Höchstwert anderer primitiver numerischer Typen in einen Single Wert konvertiert.

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      float sngValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal) ||
             value.GetType() == typeof(Double))
            sngValue = (float) value;
         else
            sngValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

open System

let values: obj list = 
    [ Byte.MinValue; Byte.MaxValue; Decimal.MinValue
      Decimal.MaxValue; Double.MinValue; Double.MaxValue
      Int16.MinValue; Int16.MaxValue; Int32.MinValue
      Int32.MaxValue; Int64.MinValue; Int64.MaxValue
      SByte.MinValue; SByte.MaxValue; UInt16.MinValue
      UInt16.MaxValue; UInt32.MinValue; UInt32.MaxValue
      UInt64.MinValue; UInt64.MaxValue ]

for value in values do
    let sngValue = 
        match value with
        | :? byte as v -> float32 v
        | :? decimal as v -> float32 v
        | :? double as v -> float32 v
        | :? int16 as v -> float32 v
        | :? int as v -> float32 v
        | :? int64 as v -> float32 v
        | :? int8 as v -> float32 v
        | :? uint16 as v -> float32 v
        | :? uint as v -> float32 v
        | :? uint64 as v -> float32 v
        | _ -> raise (NotImplementedException "Unknown Type")
    printfn $"{value} ({value.GetType().Name}) --> {sngValue:R} ({sngValue.GetType().Name})"
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim sngValue As Single
      For Each value In values
         If value.GetType() = GetType(Double) Then
            sngValue = CSng(value)
         Else
            sngValue = value
         End If
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Darüber hinaus werden die Double Werte Double.NaN, Double.PositiveInfinity, und Double.NegativeInfinity in Single.NaN, Single.PositiveInfinityund Single.NegativeInfinitykonvertiert.

Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in einen Wert zu einem Single Genauigkeitsverlust führen kann. Wie das Beispiel veranschaulicht, ist ein Genauigkeitsverlust möglich, wenn Werte, , Double, Int64Int32, UInt32und UInt64 in Single Werte konvertiert Decimalwerden.

Die Konvertierung eines Single Werts in ein Double ist eine erweiternde Konvertierung. Die Konvertierung kann zu einem Genauigkeitsverlust führen, wenn der Double Typ keine genaue Darstellung für den Single Wert aufweist.

Die Konvertierung eines Single Werts in einen Wert eines beliebigen anderen primitiven numerischen Datentyps als ein Double ist eine einschränkende Konvertierung und erfordert einen Umwandlungsoperator (in C#) oder eine Konvertierungsmethode (in Visual Basic). Werte, die sich außerhalb des Bereichs des Zieldatentyps befinden, die durch die Eigenschaften und MaxValue eigenschaften des Zieltyps MinValue definiert werden, verhalten sich wie in der folgenden Tabelle dargestellt.

Zieltyp	Ergebnis
Beliebiger integraler Typ	Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext stattfindet. Wenn die Konvertierung in einem nicht überprüften Kontext erfolgt (der Standard in C#), ist der Konvertierungsvorgang erfolgreich, aber der Wert überläuft.
Decimal	Ausnahme OverflowException :

Darüber hinaus Single.NaNlösen , Single.PositiveInfinityund Single.NegativeInfinity einen OverflowException für Konvertierungen in ganze Zahlen in einem überprüften Kontext aus, aber diese Werte überlaufen, wenn sie in ganze Zahlen in einem nicht aktivierten Kontext konvertiert werden. Bei Konvertierungen in Decimalwird immer ein OverflowExceptionausgelöst. Konvertierung in Double, sie konvertieren in Double.NaN, Double.PositiveInfinity, und Double.NegativeInfinitybzw.

Beachten Sie, dass ein Genauigkeitsverlust durch die Konvertierung eines Werts in einen Single anderen numerischen Typ entstehen kann. Beim Konvertieren nicht integraler Single Werte geht die Bruchkomponente verloren, wenn der Single Wert entweder gerundet (wie in Visual Basic) oder abgeschnitten wird (wie in C# und F#). Bei Konvertierungen in Decimal Werte hat der Single Wert möglicherweise keine genaue Darstellung im Zieldatentyp.

Im folgenden Beispiel werden mehrere Single Werte in mehrere andere numerische Typen konvertiert. Die Konvertierungen erfolgen in einem überprüften Kontext in Visual Basic (Standard), in C# (aufgrund der aktivierten Schlüsselwort (keyword)) und in F# (aufgrund der open Checked -Anweisung). Die Ausgabe des Beispiels zeigt das Ergebnis für Konvertierungen in einem aktivierten und nicht überprüften Kontext an. Sie können Konvertierungen in einem nicht überprüften Kontext in Visual Basic durchführen, indem Sie mit dem /removeintchecks+ Compilerschalter kompilieren, in C# die Anweisung auskommentieren checked und in F# die open Checked Anweisung auskommentieren.

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

open System
open Checked

let values = 
    [ Single.MinValue; -67890.1234f; -12345.6789f
      12345.6789f; 67890.1234f; Single.MaxValue
      Single.NaN; Single.PositiveInfinity
      Single.NegativeInfinity ]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."

    let dblValue = double value
    printfn $"{value} ({value.GetType().Name}) --> {dblValue} ({dblValue.GetType().Name})\n"
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Long = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try

         Dim dblValue As Double = value
         Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

Weitere Informationen zur Konvertierung numerischer Typen finden Sie unter Typkonvertierung in den .NET Framework- und Typkonvertierungstabellen.

Gleitkommafunktionalität

Die Single Struktur und die zugehörigen Typen bieten Methoden zum Ausführen der folgenden Vorgangskategorien:

• Vergleich von Werten. Sie können die Equals -Methode aufrufen, um zu bestimmen, ob zwei Single Werte gleich sind, oder die CompareTo Methode, um die Beziehung zwischen zwei Werten zu bestimmen.

  Die Single Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Sie können beispielsweise auf Gleichheit oder Ungleichheit testen oder bestimmen, ob ein Wert größer oder gleich einem anderen Wert ist. Wenn einer der Operanden ein Doubleist, wird der Single Wert vor der Durchführung des Vergleichs in ein Double konvertiert. Wenn einer der Operanden ein integraler Typ ist, wird er vor dem Vergleich in ein Single konvertiert. Obwohl es sich hierbei um erweiternde Konvertierungen handelt, können sie einen Genauigkeitsverlust mit sich bringen.

  Warnung

  Aufgrund von Genauigkeitsunterschieden können zwei Single Werte, von denen Sie erwarten, gleich sein, ungleich sein, was sich auf das Ergebnis des Vergleichs auswirkt. Weitere Informationen zum Vergleichen von zwei Single Werten finden Sie im Abschnitt Testen auf Gleichheit.

  Sie können auch die IsNaNMethoden , IsInfinity, IsPositiveInfinityund IsNegativeInfinity aufrufen, um auf diese speziellen Werte zu testen.

• Mathematische Vorgänge. Gängige arithmetische Vorgänge wie Addition, Subtraktion, Multiplikation und Division werden durch Sprachcompiler und CIL-Anweisungen (Common Intermediate Language) und nicht durch Single Methoden implementiert. Wenn der andere Operand in einem mathematischen Vorgang ein Doubleist, wird der Single in ein Double konvertiert, bevor der Vorgang ausgeführt wird, und das Ergebnis des Vorgangs ist auch ein Double Wert. Wenn der andere Operand ein integraler Typ ist, wird er vor der Ausführung des Vorgangs in einen Single konvertiert, und das Ergebnis des Vorgangs ist auch ein Single Wert.

  Sie können andere mathematische Vorgänge ausführen, indem Sie (Sharedin Visual Basic) Methoden in der System.Math -Klasse aufrufen static . Dazu gehören zusätzliche Methoden, die häufig für Arithmetik (z Math.Abs. B. , Math.Signund Math.Sqrt), geometrie (z Math.Cos . B. und Math.Sin) und Für die Berechnung (z Math.Log. B. ) verwendet werden. In allen Fällen wird der Single Wert in einen Doublekonvertiert.

  Sie können auch die einzelnen Bits in einem Single Wert bearbeiten. Die BitConverter.GetBytes(Single) -Methode gibt ihr Bitmuster in einem Bytearray zurück. Indem Sie dieses Bytearray an die BitConverter.ToInt32 -Methode übergeben, können Sie auch das Single Bitmuster des Werts in einer 32-Bit-Ganzzahl beibehalten.

• Rundung. Runden wird häufig als Technik verwendet, um die Auswirkungen von Unterschieden zwischen Werten zu reduzieren, die durch Probleme bei gleitkommabasierter Darstellung und Genauigkeit verursacht werden. Sie können einen Single Wert runden, indem Sie die Math.Round -Methode aufrufen. Beachten Sie jedoch, dass der Single Wert in ein Double konvertiert wird, bevor die Methode aufgerufen wird, und die Konvertierung einen Genauigkeitsverlust mit sich bringen kann.

• Formatierung. Sie können einen Single Wert in seine Zeichenfolgendarstellung konvertieren, indem Sie die ToString -Methode aufrufen oder das Feature für zusammengesetzte Formatierung verwenden. Informationen dazu, wie Formatzeichenfolgen die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie in den Themen Standardmäßige numerische Formatzeichenfolgen und Benutzerdefinierte numerische Formatzeichenfolgen .

• Analysieren von Zeichenfolgen. Sie können die Zeichenfolgendarstellung eines Gleitkommawerts in einen Single Wert konvertieren, indem Sie die Parse -Methode oder TryParse aufrufen. Wenn der Analysevorgang fehlschlägt, löst die Parse -Methode eine Ausnahme aus, während die TryParse -Methode zurückgibt false.

• Typkonvertierung. Die Single Struktur bietet eine explizite Schnittstellenimplementierung für die IConvertible Schnittstelle, die die Konvertierung zwischen zwei beliebigen Standard-.NET Framework-Datentypen unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten für alle anderen numerischen Standardtypen mit Ausnahme der Konvertierung von Double in Single Werte. Die Konvertierung eines Werts eines beliebigen numerischen Standardtyps mit Ausnahme eines Double in ein Single ist eine erweiternde Konvertierung und erfordert keine Verwendung eines Umwandlungsoperators oder einer Konvertierungsmethode.

  Die Konvertierung ganzzahliger 32-Bit- und 64-Bit-Werte kann jedoch zu einem Genauigkeitsverlust führen. In der folgenden Tabelle sind die Unterschiede bei der Genauigkeit für 32-Bit-, 64-Bit- und Double Typen aufgeführt:

  Typ	Maximale Genauigkeit (in Dezimalstellen)	Interne Genauigkeit (in Dezimalstellen)
  Double	15	17
  Int32 und UInt32	10	10
  Int64 und UInt64	19	19
  Single	7	9

  Das Problem der Genauigkeit wirkt sich am häufigsten auf Werte aus Single , die in Double Werte konvertiert werden. Im folgenden Beispiel sind zwei Werte, die von identischen Divisionsvorgängen erzeugt werden, ungleich, da einer der Werte ein Gleitkommawert mit einzeler Genauigkeit ist, der in einen Doublekonvertiert wird.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Double value1 = 1/3.0;
        Single sValue2 = 1/3.0f;
        Double value2 = (Double) sValue2;
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                            value1.Equals(value2));
     }
  }
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  let value1 = 1. / 3.
  let sValue2 = 1f / 3f
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1/3
        Dim sValue2 As Single = 1/3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

Felder

E	Stellt die natürliche logarithmische Basis dar, die durch die Konstante e angegeben wird.
Epsilon	Stellt den kleinsten positiven Single-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.
MaxValue	Stellt den größtmöglichen Wert von Single dar. Dieses Feld ist konstant.
MinValue	Stellt den kleinstmöglichen Wert von Single dar. Dieses Feld ist konstant.
NaN	Stellt Not-a-Number (NaN) dar. Dieses Feld ist konstant.
NegativeInfinity	Stellt minus unendlich dar. Dieses Feld ist konstant.
NegativeZero	Stellt die zahl negative Null (-0) dar.
Pi	Stellt das Verhältnis eines Kreisumfangs zum Kreisdurchmesser durch die Konstante π dar.
PositiveInfinity	Stellt plus unendlich dar. Dieses Feld ist konstant.
Tau	Stellt die Anzahl der Bogenmaßwerte in einer Umdrehung dar, angegeben durch die Konstante τ.

Methoden

Abs(Single)	Berechnet das Absolute eines Werts.
Acos(Single)	Berechnet den Arc-Kosinus eines Werts.
Acosh(Single)	Berechnet den hyperbolischen Arc-Kosinus eines Werts.
AcosPi(Single)	Berechnet den Arc-Kosinus eines Werts und dividiert das Ergebnis durch pi.
Asin(Single)	Berechnet den Arc-Sinus eines Werts.
Asinh(Single)	Berechnet den hyperbolischen Arc-Sinus eines Werts.
AsinPi(Single)	Berechnet den Arc-Sinus eines Werts und dividiert das Ergebnis durch pi.
Atan(Single)	Berechnet den Arc-Tangens eines Werts.
Atan2(Single, Single)	Berechnet den Arc-Tangens des Quotienten von zwei Werten.
Atan2Pi(Single, Single)	Berechnet den Arc-Tangens für den Quotienten zweier Werte und dividiert das Ergebnis durch pi.
Atanh(Single)	Berechnet den hyperbolischen Arc-Tangens eines Werts.
AtanPi(Single)	Berechnet den Arc-Tangens eines Werts und dividiert das Ergebnis durch pi.
BitDecrement(Single)	Dekrementiert einen Wert auf den kleinsten Wert, der kleiner als ein gegebener Wert ist.
BitIncrement(Single)	Erhöht einen Wert auf den kleinsten Wert, der größer als ein gegebener Wert ist.
Cbrt(Single)	Berechnet den Cubestamm eines Werts.
Ceiling(Single)	Berechnet die Obergrenze eines Werts.
Clamp(Single, Single, Single)	Klemmt einen Wert auf einen inklusiven Minimal- und Höchstwert.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
CompareTo(Single)	Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit einfacher Genauigkeit und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der angegebenen Gleitkommazahl mit einfacher Genauigkeit ist oder mit dieser übereinstimmt.
CopySign(Single, Single)	Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.
Cos(Single)	Berechnet den Kosinus eines Werts.
Cosh(Single)	Berechnet den hyperbolischen Kosinus eines Werts.
CosPi(Single)	Berechnet den Kosinus eines Werts, der mit pimultimultiziert wurde.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
Equals(Single)	Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Single-Objekt den gleichen Wert darstellen.
Exp(Single)	Computevorgänge werden E auf eine bestimmte Leistung angehoben.
Exp10(Single)	Computevorgänge werden 10 auf eine bestimmte Leistung angehoben.
Exp10M1(Single)	10 Berechnet auf eine bestimmte Leistung und subtrahiert eine.
Exp2(Single)	Computevorgänge werden 2 auf eine bestimmte Leistung angehoben.
Exp2M1(Single)	2 Berechnet auf eine bestimmte Leistung und subtrahiert eine.
ExpM1(Single)	E Berechnet auf eine bestimmte Leistung und subtrahiert eine.
Floor(Single)	Berechnet den Boden eines Werts.
FusedMultiplyAdd(Single, Single, Single)	Berechnet die verschmolzene Multiplikation von drei Werten.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetTypeCode()	Gibt den TypeCode für den Werttyp Single zurück.
Hypot(Single, Single)	Berechnet die Hypotenuse mit zwei Werten, die die Längen der kürzeren Seiten in einem rechtwinkligen Dreieck darstellen.
Ieee754Remainder(Single, Single)	Berechnet den Rest von zwei Werten, wie in IEEE 754 angegeben.
ILogB(Single)	Berechnet den ganzzahligen Logarithmus eines Werts.
IsEvenInteger(Single)	Bestimmt, ob ein Wert eine gerade ganzzahlige Zahl darstellt.
IsFinite(Single)	Bestimmt, ob der angegebene Wert endlich ist (Null, subnormal oder normal).
IsInfinity(Single)	Gibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.
IsInteger(Single)	Bestimmt, ob ein Wert einen integralen Wert darstellt.
IsNaN(Single)	Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl ist (NaN).
IsNegative(Single)	Bestimmt, ob der angegebene Wert negativ ist.
IsNegativeInfinity(Single)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl minus unendlich ergibt.
IsNormal(Single)	Bestimmt, ob der angegebene Wert normal ist.
IsOddInteger(Single)	Bestimmt, ob ein Wert eine ungerade ganzzahlige Zahl darstellt.
IsPositive(Single)	Bestimmt, ob ein Wert positiv ist.
IsPositiveInfinity(Single)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.
IsPow2(Single)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
IsRealNumber(Single)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
IsSubnormal(Single)	Bestimmt, ob der angegebene Wert subnormal ist.
Log(Single)	Berechnet den natürlichen (base-E Logarithmus eines Werts.
Log(Single, Single)	Berechnet den Logarithmus eines Werts in der angegebenen Basis.
Log10(Single)	Berechnet den Basis-10-Logarithmus eines Werts.
Log10P1(Single)	Berechnet den Basis-10-Logarithmus eines Werts plus 1.
Log2(Single)	Berechnet das Protokoll2 eines Werts.
Log2P1(Single)	Berechnet den Basis-2-Logarithmus eines Werts plus eins.
LogP1(Single)	Berechnet den natürlichen Logarithmus (base-E) eines Werts plus eins.
Max(Single, Single)	Vergleicht zwei Werte mit einem höheren Computewert.
MaxMagnitude(Single, Single)	Vergleicht zwei Werte mit einem höheren Computewert.
MaxMagnitudeNumber(Single, Single)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe hat, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
MaxNumber(Single, Single)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
Min(Single, Single)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(Single, Single)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitudeNumber(Single, Single)	Vergleicht zwei Werte mit einer Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
MinNumber(Single, Single)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.
Pow(Single, Single)	Berechnet einen Wert, der auf eine bestimmte Leistung angehoben wird.
ReciprocalEstimate(Single)	Berechnet eine Schätzung des Kehrwerts eines Werts.
ReciprocalSqrtEstimate(Single)	Berechnet eine Schätzung der reziproken Quadratwurzel eines Werts.
RootN(Single, Int32)	Berechnet den n-ten Stamm eines Werts.
Round(Single)	Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf die nächste ganze Zahl.
Round(Single, Int32)	Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.
Round(Single, Int32, MidpointRounding)	Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.
Round(Single, MidpointRounding)	Rundet einen Wert mithilfe des angegebenen Rundungsmodus auf die nächste ganze Zahl.
ScaleB(Single, Int32)	Berechnet das Produkt eines Werts und dessen Basisradix, der auf die angegebene Leistung angehoben wird.
Sign(Single)	Berechnet das Vorzeichen eines Werts.
Sin(Single)	Berechnet den Sinus eines Werts.
SinCos(Single)	Berechnet den Sinus und den Kosinus eines Werts.
SinCosPi(Single)	Berechnet den Sinus und den Kosinus eines Werts.
Sinh(Single)	Berechnet den hyperbolischen Sinus eines Werts.
SinPi(Single)	Berechnet den Sinus eines Werts, der mit pimultipliziert wurde.
Sqrt(Single)	Berechnet die Quadratwurzel eines Werts.
Tan(Single)	Berechnet den Tangens eines Werts.
Tanh(Single)	Berechnet den hyperbolischen Tangens eines Werts.
TanPi(Single)	Berechnet den Tangens eines Werts, der mit pimultimultiziert wurde.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Truncate(Single)	Schneidet einen Wert ab.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz der Gleitkommazahl in die angegebene Zeichenspanne zu formatieren
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(ReadOnlySpan<Char>, Single)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer Zeichenspanne in die entsprechende Gleitkommazahl mit einfacher Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, IFormatProvider, Single)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, NumberStyles, IFormatProvider, Single)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, Single)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit einfacher Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Operatoren

Equality(Single, Single)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Single-Werte gleich sind.
GreaterThan(Single, Single)	Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer als ein anderer angegebener Single-Wert ist.
GreaterThanOrEqual(Single, Single)	Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer oder gleich einem anderen angegebenen Single-Wert ist.
Inequality(Single, Single)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Single-Werte gleich sind.
LessThan(Single, Single)	Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer als ein anderer angegebener Single-Wert ist.
LessThanOrEqual(Single, Single)	Gibt einen Wert zurück, der angibt, ob ein angegebener Single -Wert kleiner oder gleich einem anderen angegebenen Single-Wert ist.

Explizite Schnittstellenimplementierungen

IAdditionOperators<Single,Single,Single>.Addition(Single, Single)	Fügt zwei Werte zusammen, um deren Summe zu berechnen.
IAdditiveIdentity<Single,Single>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryNumber<Single>.AllBitsSet	Ruft eine instance des binären Typs ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<Single,Single,Single>.BitwiseAnd(Single, Single)	Berechnet das bitweise und von zwei Werten.
IBitwiseOperators<Single,Single,Single>.BitwiseOr(Single, Single)	Berechnet das bitweise oder von zwei Werten.
IBitwiseOperators<Single,Single,Single>.ExclusiveOr(Single, Single)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<Single,Single,Single>.OnesComplement(Single)	Berechnet die Eins-Komplement-Darstellung eines angegebenen Werts.
IConvertible.ToBoolean(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDateTime(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).
IDecrementOperators<Single>.Decrement(Single)	Verringert einen Wert.
IDivisionOperators<Single,Single,Single>.Division(Single, Single)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IFloatingPoint<Single>.GetExponentByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32)geschrieben werden.
IFloatingPoint<Single>.GetExponentShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Exponenten in Bits ab.
IFloatingPoint<Single>.GetSignificandBitLength()	Ruft die Länge des aktuellen Significand in Bits ab.
IFloatingPoint<Single>.GetSignificandByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32)geschrieben werden.
IFloatingPoint<Single>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten im Big-Endian-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Single>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Single>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Versucht, die aktuelle Significand im Big-Endian-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Single>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Significand im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IFloatingPointConstants<Single>.E	Ruft die mathematische Konstante eab.
IFloatingPointConstants<Single>.Pi	Ruft die mathematische Konstante piab.
IFloatingPointConstants<Single>.Tau	Ruft die mathematische Konstante tauab.
IFloatingPointIeee754<Single>.Epsilon	Ruft den kleinsten Wert ab, der hinzugefügt werden kann, was nicht zu 0 führt 0.
IFloatingPointIeee754<Single>.NaN	Ruft einen Wert ab, der darstellt NaN.
IFloatingPointIeee754<Single>.NegativeInfinity	Ruft einen Wert ab, der das negative infinitydarstellt.
IFloatingPointIeee754<Single>.NegativeZero	Ruft einen Wert ab, der das negative zerodarstellt.
IFloatingPointIeee754<Single>.PositiveInfinity	Ruft einen Wert ab, der positive infinitydarstellt.
IIncrementOperators<Single>.Increment(Single)	Erhöht einen Wert.
IMinMaxValue<Single>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Single>.MinValue	Ruft den Minimalwert des aktuellen Typs ab.
IModulusOperators<Single,Single,Single>.Modulus(Single, Single)	Dividiert zwei Werte, um ihren Modulus oder Rest zu berechnen.
IMultiplicativeIdentity<Single,Single>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<Single,Single,Single>.Multiply(Single, Single)	Multipliziert zwei Werte, um ihr Produkt zu berechnen.
INumberBase<Single>.IsCanonical(Single)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Single>.IsComplexNumber(Single)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Single>.IsImaginaryNumber(Single)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Single>.IsZero(Single)	Bestimmt, ob ein Wert 0 ist.
INumberBase<Single>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Single>.Radix	Ruft die Basis für den Typ ab.
INumberBase<Single>.TryConvertFromChecked<TOther>(TOther, Single)	Stellt eine Gleitkommazahl mit einfacher Genauigkeit dar.
INumberBase<Single>.TryConvertFromSaturating<TOther>(TOther, Single)	Stellt eine Gleitkommazahl mit einfacher Genauigkeit dar.
INumberBase<Single>.TryConvertFromTruncating<TOther>(TOther, Single)	Stellt eine Gleitkommazahl mit einfacher Genauigkeit dar.
INumberBase<Single>.TryConvertToChecked<TOther>(Single, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch eine Überlaufausnahme für alle Werte ausgelöst wird, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Single>.TryConvertToSaturating<TOther>(Single, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen, gesättigt werden.
INumberBase<Single>.TryConvertToTruncating<TOther>(Single, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Single>.Zero	Ruft den Wert 0 für den Typ ab.
ISignedNumber<Single>.NegativeOne	Ruft den Wert -1 für den Typ ab.
ISubtractionOperators<Single,Single,Single>.Subtraction(Single, Single)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<Single,Single>.UnaryNegation(Single)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Single,Single>.UnaryPlus(Single)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Elemente, die instance Zustand ändern, geben tatsächlich eine neue instance zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen

• Decimal
• Double