Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Single-Struktur

 

Veröffentlicht: Oktober 2016

Stellt eine Gleitkommazahl mit einfacher Genauigkeit dar.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Single : IComparable, IFormattable, IConvertible, 
	IComparable<float>, IEquatable<float>

NameBeschreibung
System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodEquals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.(Überschreibt ValueType.Equals(Object).)

System_CAPS_pubmethodEquals(Single)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Single-Objekt den gleichen Wert darstellen.

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Instanz zurück.(Überschreibt ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodGetTypeCode()

Gibt den TypeCode für den Werttyp Single zurück.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Single)

Gibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Single)

Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl ist (NaN).

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Single)

Gibt einen Wert zurück, der angibt, ob die angegebene Zahl minus unendlich ergibt.

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Single)

Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit einfacher Genauigkeit.

System_CAPS_pubmethodToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.(Überschreibt ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

System_CAPS_pubmethodToString(String)

Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.

System_CAPS_pubmethodToString(String, IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Single)

Konvertiert die Zeichenfolgenentsprechung einer Zahl in die entsprechende Gleitkommazahl mit einfacher Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

NameBeschreibung
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

Stellt den kleinsten positiven Single-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Stellt den größtmöglichen Wert von Single dar. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Stellt den kleinstmöglichen Wert von Single dar. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticNaN

Stellt Not-a-Number (NaN) dar. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

Stellt minus unendlich dar. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

Stellt plus unendlich dar. Dieses Feld ist konstant.

NameBeschreibung
System_CAPS_puboperatorSystem_CAPS_staticEquality(Single, Single)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Single-Werte gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Single, Single)

Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer als ein anderer angegebener Single-Wert ist.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Single, Single)

Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer oder gleich einem anderen angegebenen Single-Wert ist.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Single, Single)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Single-Werte gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Single, Single)

Gibt einen Wert zurück, der angibt, ob ein angegebener Single-Wert größer als ein anderer angegebener Single-Wert ist.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Single, Single)

Gibt einen Wert zurück, der angibt, ob ein angegebener Single -Wert kleiner oder gleich einem anderen angegebenen Single-Wert ist.

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter IConvertible.ToUInt64.

Die Single Wert stellt eine 32-Bit-Zahl mit einfacher Genauigkeit im Bereich von negativen 3. 402823E38 bis positive 3. 402823E38 sowie positive oder negative 0 (null), PositiveInfinity, NegativeInfinity, und keine Zahl (NaN). Es soll, sind (z. B. die Abstände zwischen Planeten oder Galaxien) sehr groß oder sehr klein ist (z. B. der molekularen Masse einer Substanz in Kilogramm) und, die häufig ungenauen (z. B. der Abstand von der Erde zu einem anderen Sonnensystem) Werte darstellen. Die Single Geben die IEC 60559: 1989 (IEEE 754) für binäre Gleitkommaarithmetik standard entspricht.

Dieses Thema enthält folgende Abschnitte:

System.Single Stellt Methoden zum Vergleichen von Instanzen dieses Typs, um den Wert einer Instanz in die Zeichenfolgendarstellung zu konvertieren und die Darstellung einer Zahl in eine Instanz dieses Typs zu konvertieren. Informationen zur Steuerung der Darstellung von Werttypen mit Format-Spezifikation Codes finden Sie unter Formatieren von Typen in .NET Framework, Standardmäßige Zahlenformatzeichenfolgen, und Benutzerdefinierte Zahlenformatzeichenfolgen.

Die Single -Datentyp speichert Gleitkommawerte mit einfacher Genauigkeit in einem 32-Bit-Binärformat, wie in der folgenden Tabelle dargestellt:

Segment

Bits

Signifikanden oder Mantisse

0-22

Exponent

23-30

Zeichen (0 = positiv, 1 = negativ)

31

Genau wie dezimalen nicht einige Bruchwerte exakt dargestellt werden (z. B. 1/3 oder Math.PI), binäre Brüche sind nicht einige Bruchzahlen darstellen. 2 bis 10, der genau durch.2 als Dezimalbruch dargestellt wird, wird z. B. durch.0011111001001100 als Binärbruch mit dem Muster "1100" wiederholten unendlich dargestellt. In diesem Fall bietet der Gleitkommawert eine ungenaue Darstellung der Zahl, die es darstellt. Zusätzliche mathematische Operationen für den ursprünglichen Gleitkommawert häufig ausführen, erhöht den Mangel an Genauigkeit. Beispielsweise erzeugt, wenn die Ergebnisse der Multiplikation.3 von 10 und.3,.3 neun Mal hinzufügen, zusätzlich angezeigt wird weniger präzise Ergebnis, da sie acht weitere Vorgänge als Multiplikation umfasst. Beachten Sie, dass diese Ungleichheit ist offensichtlich nur, wenn Sie die beiden anzeigen Single Werte mithilfe der "R" Standardformatzeichenfolge, die, wenn nötig, zeigt alle 9 Ziffern von unterstützt die Single Typ.

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

Da einige Zahlen genauso wie binäre Bruchzahlen dargestellt werden können, können Gleitkommazahlen ungefähre reelle Zahlen.

Alle Gleitkommazahlen haben eine begrenzte Anzahl von signifikanten Stellen, die auch bestimmt, wie genau ein Gleitkommawert mit eine reellen Zahl entspricht. Ein Single Wert hat bis zu 7 Dezimalstellen, obwohl intern maximal 9 Ziffern gespeichert wird. Dies bedeutet, dass manche Gleitkommaoperationen, die Genauigkeit fehlen um einen Gleitkommawert zu ändern. Das folgende Beispiel definiert einen großen Gleitkommawert mit einfacher Genauigkeit, und fügt dann das Produkt der Single.Epsilon und dabei darauf. Allerdings ist das Produkt zu klein, um die ursprünglichen Gleitkommawert ändern. Die am wenigsten signifikanten Ziffer ist, Zehntausendstel-, während die signifikanteste Ziffer des Produkts 1-312.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123456789e4f;
      Single additional = Single.Epsilon * 1e12f;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    1.234568E+12 + 1.401298E-33 = 1.234568E+12

Der eingeschränkte Genauigkeit einer Gleitkommazahl hat mehrere folgen:

  • Zwei Gleitkommazahlen, die für eine bestimmte Genauigkeit identisch erscheinen möglicherweise nicht gleich, da die letzten gültigen Ziffern unterscheiden. Im folgenden Beispiel werden eine Reihe von Zahlen addiert und die Summe wird mit ihren erwartete Summe verglichen. Die zwei Werte übereinstimmen, einen Aufruf von scheinbar die Equals -Methode gibt an, dass dies nicht der Fall.

    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:R}) does not equal the total ({1:R}).",
                               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).   
    

    Wenn Sie die Formatelemente in Ändern der Console.WriteLine(String, Object, Object) -Anweisung {0} und {1}{0:R} und {1:R} anzuzeigenden alle signifikanten Ziffern der beiden Single Werte, es ist klar, dass die beiden Werte ungleich aufgrund einer Unterbrechung der Genauigkeit während der Vorgänge hinzufügen. In diesem Fall kann das Problem behoben werden, durch Aufrufen der Math.Round(Double, Int32) -Methode rundet die Single Werte vor dem Vergleich der gewünschten Genauigkeit.

  • Ein mathematischer oder Vergleichsoperation Vorgang, der eine Gleitkommazahl verwendet möglicherweise nicht zum gleiche Ergebnis führen, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht die Dezimalzahl Wert. In einem vorherigen Beispiel veranschaulicht dies durch Anzeigen des Ergebnisses der Multiplikation.3 von 10 und.3,.3 neun Mal hinzufügen.

    Wenn die Genauigkeit der numerischen Operationen Teilwerte wichtig ist, verwenden die Decimal anstelle des der Single Typ. Bei der Genauigkeit der numerischen Operationen mit ganzzahligen Werten außerhalb des Gültigkeitsbereichs für die Int64 oder UInt64 Typen ist wichtig, verwenden Sie die BigInteger Typ.

  • Ein Wert möglicherweise nicht erhalten, wenn eine Gleitkommazahl einbezogen ist. Ein Wert wird als Roundtrip bezeichnet, wenn ein Vorgang eine ursprüngliche Gleitkommazahl in ein anderes Format konvertiert, ein umgekehrter Vorgang das konvertierte Format zurück in eine Gleitkommazahl transformiert und die endgültige Gleitkommazahl der ursprünglichen Gleitkommazahl entspricht. Der Roundtrip kann fehlschlagen, da eine oder mehrere Ziffern verloren oder eine Konvertierung geändert werden. Im folgenden Beispiel drei Single Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert werden. Wie die Ausgabe zeigt zwar die Werte identisch sind, sind die wiederhergestellten Werte nicht gleich auf die ursprünglichen Werte.

    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
    

    In diesem Fall die Werte kann erfolgreich Roundtrip mithilfe der "R" Standardformatzeichenfolge die vollständige Genauigkeit beibehalten Single Werte, 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:R}{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
    
  • Single Werte müssen geringerer Genauigkeit als Double Werte. Ein Single -Wert, der in einem scheinbar Äquivalent konvertiert wird Double häufig entspricht nicht der Double Wert aufgrund der Unterschiede in der Genauigkeit. Im folgenden Beispiel wird das Ergebnis der Division identische Vorgänge zu zugewiesen ein Double Wert und einen Single Wert. Nach der Single Wert umgewandelt wird ein Double, ein Vergleich der beiden Werte zeigt an, 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
    

    Um dieses Problem zu vermeiden, verwenden Sie entweder die Double Datentyp anstelle von der Single -Datentyp, oder verwenden die Round Methode so, dass beide Werte die gleiche Genauigkeit haben.

Um als gleich betrachtet werden zwei Single Werte müssen identische Werte darstellen. Jedoch aktivieren, aufgrund der Unterschiede in der Genauigkeit zwischen Werten oder aufgrund einer Unterbrechung der Genauigkeit von einer oder beide Werte, Gleitkommawerte, die voraussichtlich häufig identisch sind aufgrund von Unterschieden in den letzten Ziffern berücksichtigt werden. Daher aufruft, um die Equals Methode, um zu bestimmen, ob zwei Werte gleich sind, oder Aufrufe der CompareTo Methode, um die Beziehung zwischen zwei bestimmen Single Werte führen häufig zu unerwarteten Ergebnissen. Dies ist im folgenden Beispiel ersichtlich, in denen gleich zwei anscheinend Single Werte erweisen, ungleich, da der erste Wert einer Genauigkeit von 7 Stellen hat, während der zweite Wert 9 verfügt.

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

Berechnete Werte, die verschiedenen Codepfaden folgen und, unterschiedlich oft bearbeitet, nachweisen berücksichtigt werden. Im folgenden Beispiel ein Single Wert quadriert, und klicken Sie dann die Quadratwurzel berechnet wird, um den ursprünglichen Wert wiederherstellen. Eine zweite Single 3.51 multipliziert und Quadrat, bevor die Quadratwurzel des Ergebnisses durch 3.51 zum Wiederherstellen des ursprünglichen Wert dividiert wird. Die zwei Werte übereinstimmen, scheinbar einen Aufruf von der Equals(Single) -Methode gibt an, dass sie nicht gleich sind. Mit der Standardformatzeichenfolge "R" um eine Ergebniszeichenfolge zurückzugeben, die alle signifikanten Ziffern der einzelnen zeigt Single Wert zeigt an, dass der zweite Wert.0000000000001 kleiner als das erste.

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:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

In Fällen, in denen ein Verlust an Genauigkeit, die das Ergebnis eines Vergleichs beeinflussen, können Sie die folgenden Techniken verwenden, statt die Equals oder CompareTo Methode:

  • Rufen Sie die Math.Round Methode, um sicherzustellen, dass beide Werte die gleiche Genauigkeit. Das folgende Beispiel ändert die einem vorherigen Beispiel zum Verwenden dieses Ansatzes, sodass zwei Bruchzahlen äquivalent 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
    

    Beachten Sie, dass das Problem der Genauigkeit weiterhin zum Runden der Mittelpunkt-Werte gilt. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).

  • Ungefähre Gleichheit statt auf Gleichheit zu testen. Dieses Verfahren erfordert, dass Sie entweder ein absoluter definieren Betrag, mit dem die beiden Werte unterscheiden können, aber auch, gleich sein, oder, die Sie definieren eine relative Menge, der jeweils kleinere Wert aus der jeweils größere Wert voneinander abweichen kann.

    System_CAPS_warningWarnung

    Single.Epsilon wird manchmal als ein Maß für den Abstand zwischen zwei absolute verwendet Single Werten, wenn Tests auf Gleichheit. Allerdings Single.Epsilon misst den kleinstmöglichen Wert, der hinzugefügt oder davon subtrahiert werden kann ein Single deren Wert 0 (null) ist. Für die meisten Positive und negative Single Werte wird der Wert des Single.Epsilon ist zu klein ist, um erkannt zu werden. Aus diesem Grund mit Ausnahme der Werte, die NULL sind, empfohlen nicht die Verwendung in Gleichheit.

    Im folgenden Beispiel wird den zweiten Ansatz zum Definieren einer IsApproximatelyEqual -Methode, die die relative Differenz zwischen zwei Werten testet. Das Ergebnis der Aufrufe auch gegenübergestellt die IsApproximatelyEqual Methode und die Equals(Single) Methode.

    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
    

Operationen mit Gleitkommazahlen lösen keine Ausnahmen, im Gegensatz zu Operationen mit ganzzahligen Typen, die Ausnahmen in Fällen unzulässigen Vorgängen, z. B. Division durch null oder ein Überlauffehler auslösen. Stattdessen ist das Ergebnis einer Gleitkommaoperation in diesen Fällen 0 (null), unendlich, negativ unendlich oder keine Zahl (NaN):

  • Wenn das Ergebnis einer Gleitkommaoperation für das Zielformat zu klein ist, ist das Ergebnis 0 (null). Dies kann auftreten, wenn zwei sehr kleine Gleitkommazahlen, wie im folgenden Beispiel gezeigt multipliziert werden.

    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
    
  • Wenn das Ergebnis einer Gleitkommaoperation des Bereichs des Ziel-Formats überschreitet, ist das Ergebnis des Vorgangs PositiveInfinity oder NegativeInfinity, für das Vorzeichen des Ergebnisses. Das Ergebnis einer Operation, die größer sind als Single.MaxValue ist PositiveInfinity, und das Ergebnis einer Operation, die größer sind als Single.MinValue ist NegativeInfinity, wie im folgende Beispiel gezeigt.

    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
    

    PositiveInfinity auch aus einer Division durch 0 (null) mit einer positiven Dividend, Ergebnisse und NegativeInfinity führt eine Division durch 0 (null) mit einem negativen Dividend.

  • Wenn eine Gleitkommaoperation ungültig ist, ist das Ergebnis des Vorgangs NaN. Z. B. NaN ergibt, die folgenden Vorgänge:

    • Division durch Null mit Dividenden 0 (null). Beachten Sie, dass andere Fälle der Division durch 0 (null) Ergebnis entweder PositiveInfinity oder NegativeInfinity.

    • Jeder Gleitkommaoperation mit ungültige Eingabe. Beispielsweise versucht gefunden wird, gibt die Quadratwurzel eines negativen Werts NaN.

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

Die Single Struktur definiert kein explizite oder implizite Konvertierungsoperatoren; stattdessen Konvertierungen vom Compiler implementiert werden.

Die folgende Tabelle enthält die möglichen Konvertierungen mit einem Wert von der anderen primitiven numerischen Typen zur ein Single Wert, es gibt auch an, ob die Konvertierung erweiternde oder einschränkende und ob das resultierende Single möglicherweise kleiner als der ursprüngliche Wert mit einfacher Genauigkeit.

Konvertierung von

Widening/einschränkende

Verlust der Genauigkeit

Byte

Widening

Nein

Decimal

Widening

Beachten Sie, dass c# Umwandlungsoperatoren erfordert.

Ja. Decimal unterstützt die Genauigkeit von 29 Ziffern. Single 9 unterstützt.

Double

Einschränkende; Werte außerhalb des Bereichs in konvertiert Double.NegativeInfinity oder Double.PositiveInfinity.

Ja. Double unterstützt die Genauigkeit von 17 Dezimalziffern. Single 9 unterstützt.

Int16

Widening

Nein

Int32

Widening

Ja. Int32 unterstützt die Genauigkeit von 10 Ziffern. Single 9 unterstützt.

Int64

Widening

Ja. Int64 unterstützt 19 Dezimalstellen. Single 9 unterstützt.

SByte

Widening

Nein

UInt16

Widening

Nein

UInt32

Widening

Ja. UInt32 unterstützt die Genauigkeit von 10 Ziffern. Single 9 unterstützt.

UInt64

Widening

Ja. Int64 unterstützt die Genauigkeit von 20 Dezimalziffern. Single 9 unterstützt.

Im folgenden Beispiel konvertiert die minimalen oder maximalen Wert von anderen primitiven numerischen Typen an ein Single Wert.

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)

Darüber hinaus die Double Werte Double.NaN, Double.PositiveInfinity, und Double.NegativeInfinity konvertieren, Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinity, bzw..

Beachten Sie, dass die Konvertierung des Wertes einiger numerischen Typen an ein Single Wert kann mit einem Genauigkeitsverlust verbunden. Wie im Beispiel veranschaulicht, ein Genauigkeitsverlust kann bei der Konvertierung Decimal, Double, Int32, Int64, UInt32, und UInt64 Werte Single Werte.

Die Konvertierung von einem Single -Wert in eine Double eine erweiternde Konvertierung wird. Die Konvertierung kann zu einem Genauigkeitsverlust führen, wenn die Double -Typ verfügt nicht über eine genaue Darstellung der Single Wert.

Die Konvertierung von einem Single auf einen Wert, der alle primitiven numerischen Datentyp anderen Wert als eine Double ist eine einschränkende Konvertierung und erfordert ein Umwandlungsoperator (in c#) oder eine Konvertierungsmethode (in Visual Basic). Werte, die außerhalb des Bereichs des Zieltyps Daten sind durch des Zieltyps definiert MinValue und MaxValue Eigenschaften, verhalten sich wie in der folgenden Tabelle dargestellt.

Zieltyp

Ergebnis

Ganzzahlige Typen

Eine OverflowException -Ausnahme aus, wenn die Konvertierung in einem überprüften Kontext auftritt.

Wenn die Konvertierung in einem nicht geprüften Kontext (die Standardeinstellung in c#), erfolgt die Konvertierung erfolgreich ist, aber der Wert überläuft.

Decimal

Ein OverflowException Ausnahme

Darüber hinaus Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinity löst ein OverflowException für die Konvertierung zu einer ganzen Zahl in einem überprüften Kontext, aber diese Werte Überlauf beim Konvertieren in ganzen Zahlen in einem nicht geprüften Kontext. Für die Konvertierung in Decimal, sie immer eine Ausnahme auslösen einer OverflowException. Für die Konvertierung in Double, konvertieren sie Sie in Double.NaN, Double.PositiveInfinity, und Double.NegativeInfinity, bzw..

Beachten Sie, dass es sich bei einem Genauigkeitsverlust führen kann, durch Konvertieren einer Single Wert in einen anderen numerischen Typ. Bei der Konvertierung nicht ganzzahligen Double Werte, wie die Ausgabe des Beispiels zeigt, der Nachkommawert wird abgebrochen, wenn der Single Wert gerundet (wie in Visual Basic) oder (wie in c#) abgeschnitten. Für die Konvertierung in Decimal und Single Werte, die Double Wert möglicherweise nicht präzise dargestellt in den Zieldatentyp.

Im folgende Beispiel konvertiert eine Zahl von Single auf verschiedene andere numerische Werte. Die Konvertierung in einem überprüften Kontext in Visual Basic (Standard) und in c# auftreten (aufgrund der der überprüft Schlüsselwort). Die Ausgabe im Beispiel zeigt das Ergebnis für die Konvertierung in einen aktivierten einem nicht geprüften Kontext. Führen Sie Konvertierungen in einem nicht geprüften Kontext in Visual Basic, durch die Kompilierung mit der /removeintchecks+ Compilerschalter und in c# Auskommentieren der checked Anweisung.

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)

Weitere Informationen zur Konvertierung von numerischen Typen finden Sie unter Typkonvertierung in .NET Framework und Typkonvertierungstabellen in .NET Framework.

Die Single -Struktur und verwandte Typen bieten Methoden, um die folgenden Kategorien von Vorgänge auszuführen:

  • Vergleich der Werte. Rufen Sie die Equals Methode, um zu bestimmen, ob zwei Single Werte gleich sind, oder die CompareTo Methode, um die Beziehung zwischen zwei Werten festzulegen.

    Die Single Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Sie können z. B. für Gleichheit oder Ungleichheit testen oder bestimmen, ob ein Wert größer als oder gleich einem anderen Wert ist. Wenn einer der Operanden ist ein Double, der Single Wert konvertiert eine Double vor dem Vergleich. Wenn einer der Operanden ein Ganzzahltyp ist, wird es in konvertiert eine Single vor dem Vergleich. Obwohl diese erweiternde Konvertierungen sind, können sie ein Genauigkeitsverlust führen.

    System_CAPS_warningWarnung

    Aufgrund der Unterschiede in der Genauigkeit zwei Single Werte, die gleich sein sollen möglicherweise erweisen sich als ungleich, dies wirkt sich auf das Ergebnis des Vergleichs. Finden Sie unter der Testen auf Gleichheit Abschnitt, um weitere Informationen zum Vergleichen von zwei Single Werte.

    Sie können auch aufrufen, die IsNaN, IsInfinity, IsPositiveInfinity, und IsNegativeInfinity Methoden für diese speziellen Werte zu testen.

  • Mathematische Operationen. Allgemeine arithmetische Operationen wie Addition, Subtraktion, Multiplikation und Division werden durch Sprachcompiler und Common Intermediate Language (CIL)-Anweisungen anstelle von implementiert Single Methoden. Ist der andere Operand in einer mathematischen Operation eine Double, die Single konvertiert eine Double vor dem Ausführen des Vorgangs, und das Ergebnis des Vorgangs auch ein Double Wert. Wenn der andere Operand ein Ganzzahltyp ist, wird es in konvertiert eine Single vor dem Ausführen des Vorgangs, und das Ergebnis des Vorgangs auch ein Single Wert.

    Sie können andere mathematischen Operationen ausführen, durch Aufrufen von static (Shared in Visual Basic) Methoden in der System.Math Klasse. Dazu gehören Weitere häufig verwendete Methoden (z. B. Math.Abs, Math.Sign, und Math.Sqrt), Geometrie (z. B. Math.Cos und Math.Sin), und aus (z. B. Math.Log). In allen Fällen die Single Wert konvertiert eine Double.

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

  • Runden. Rundung wird häufig als eine Technik zum Schädigung von Unterschieden zwischen Probleme gleitkommadarstellung und Genauigkeit. Abrunden einer Single -Wert durch Aufrufen der Math.Round Methode. Beachten Sie jedoch, dass die Single Wert konvertiert ein Double bevor die Methode wird aufgerufen, und die Konvertierung kann mit einem Genauigkeitsverlust verbunden.

  • Formatierung. Sie konvertieren eine Single Wert, der die Zeichenfolgendarstellung durch Aufrufen der ToString Methode oder mithilfe der kombinierte Formatierung Funktion. Informationen zum Steuern der Darstellung von Gleitkommawerten in Formatzeichenfolgen finden Sie unter der Standardmäßige Zahlenformatzeichenfolgen und Benutzerdefinierte Zahlenformatzeichenfolgen Themen.

  • Analysieren von Zeichenfolgen. Sie können die Darstellung des einen Gleitkommawert auf Konvertieren einer Single -Wert durch Aufrufen der Parse oder TryParse Methode. Wenn der Analysevorgang fehlschlägt, die Parse Methode löst eine Ausnahme aus, während die TryParse -Methode gibt false.

  • Typkonvertierung. Die Single Struktur stellt eine explizite Implementierung für die IConvertible -Schnittstelle, die Konvertierung zwischen jeder zwei standardmäßigen .NET Framework-Datentypen unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten für alle anderen standardmäßigen numerischen Datentypen mit Ausnahme der Konvertierung Double zu Single Werte. Konvertierung eines Werts für alle standardmäßigen numerischen Typen außer einer Double zu einer Single eine erweiternde Konvertierung wird und die Verwendung einer Umwandlung Operator oder Konvertierung-Methode ist nicht erforderlich.

    Konvertierung von 32-Bit- und 64-Bit-Ganzzahlwerten kann jedoch einem Genauigkeitsverlust führen. Die folgende Tabelle listet die Unterschiede in der Genauigkeit für 32-Bit, 64-Bit- und Double Typen:

    Type

    Maximale Genauigkeit (Dezimalstellen)

    Interne Genauigkeit (Dezimalstellen)

    Double

    15

    17

    Int32 und UInt32

    10

    10

    Int64 und UInt64

    19

    19

    Single

    7

    9

    Die Genauigkeit am häufigsten Problems Single Werte, die konvertiert werden Double Werte. Im folgenden Beispiel zwei identische Divisionsoperationen gefertigten Werte ungleich sind, ist einer der Werte einen Gleitkommawert mit einfacher Genauigkeit, die Konvertierung in eine Double.

    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
    

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle Member dieses Typs sind threadsicher. Elemente, die angezeigt werden, so ändern Sie den Zustand der Instanz zurück tatsächlich eine neue Instanz mit dem neuen Wert initialisiert. Als müssen bei allen anderen Typen müssen Lese- und Schreibzugriffe auf eine freigegebene Variable, die eine Instanz dieses Typs enthält durch eine Sperre auf die Threadsicherheit geschützt werden.

Zurück zum Anfang
Anzeigen: