Windows-Apps
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
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
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

Double-Struktur

 

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.

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

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

NameBeschreibung
System_CAPS_pubmethodCompareTo(Double)

Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit doppelter Genauigkeit und gibt eine Ganzzahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist oder mit dieser übereinstimmt.

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_pubmethodEquals(Double)

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

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_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 Double zurück.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Double)

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 doppelter Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter 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, Double)

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

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Double)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

NameBeschreibung
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

Stellt den kleinsten positiven Double-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 Double dar. Dieses Feld ist konstant.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

System_CAPS_pubfieldSystem_CAPS_staticNaN

Stellt einen Wert dar, der keine Zahl ist (NaN). 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(Double, Double)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Double, Double)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Double, Double)

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

System_CAPS_puboperatorSystem_CAPS_staticInequality(Double, Double)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Double, Double)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Double, Double)

Gibt einen Wert zurück, der angibt, ob ein angegebener Double -Wert kleiner oder gleich einem anderen angegebenen Double-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 Double Werttyp stellt eine 64-Bit-Zahl mit doppelter Genauigkeit mit Werten von negativen 1. 79769313486232e308 positive 1. 79769313486232e308 sowie positive oder negative 0 (null), PositiveInfinity, NegativeInfinity, und keine Zahl (NaN). Es soll die Werte darstellen, sind (z. B. die Abstände zwischen Planeten oder Galaxien) sehr groß oder sehr klein (molekularen Masse einer Substanz in Kilogramm) und häufig ungenauen (z. B. den Abstand zwischen Erde und anderen Sonnensystem), sind die Double Typ der IEC 60559: 1989 (IEEE 754) für binäre Gleitkommaarithmetik standard entspricht.

Dieses Thema enthält folgende Abschnitte:

Die Double -Datentyp speichert Gleitkommawerte mit doppelter Genauigkeit in eine 64-Bit-Binärformat, wie in der folgenden Tabelle dargestellt:

Segment

Bits

Signifikanden oder Mantisse

0-51

Exponent

52-62

Zeichen (0 = positiv, 1 = negativ)

63

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. 1 bis 10, der genau durch.1 als Dezimalbruch dargestellt wird, wird z. B. durch.001100110011 als Binärbruch mit dem Muster "0011" 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 ist der Mangel an Genauigkeit zu erhöhen. Wenn wir das Ergebnis Vergleichen der Multiplikation von 10.1 hinzufügen.1 zu.1 neun Mal, wir finden Sie unter, hinzufügen, da es acht weitere Vorgänge beteiligt ist, hat z. B. das weniger präzise Ergebnis erzeugt. Beachten Sie, dass diese Ungleichheit ist offensichtlich nur, wenn wir die beiden anzeigen Double Werte mithilfe der "R" Standardformatzeichenfolge, die ggf. alle 17 Ziffern von unterstützten angezeigt der Double Typ.

using System;

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

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

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

Alle Gleitkommazahlen haben auch eine begrenzte Anzahl von signifikanten Stellen, die auch bestimmt, wie genau ein Gleitkommawert mit eine reellen Zahl entspricht. Ein Double Wert hat bis zu 15 Dezimalstellen, Genauigkeit, obwohl intern ein Maximum von 17 Ziffern gespeichert wird. Dies bedeutet, dass manche Gleitkommaoperationen, die Genauigkeit fehlen um einen Gleitkommawert ändern Datenpunktwert. Dies wird im folgenden Beispiel veranschaulicht. Er definiert einen sehr großen Gleitkommawert, und fügt dann das Produkt der Double.Epsilon und dabei darauf. Das Produkt ist jedoch 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()
   {
      Double value = 123456789012.34567;
      Double additional = Double.Epsilon * 1e15;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

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()
       {
          Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 };
          Double result = 27.64;
          Double total = 0;
          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 (36.64) does not equal the total (36.64).   
    //
    // 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 Ändern der Console.WriteLine(String, Object, Object) -Anweisung {0} und {1}{0:R} und {1:R} anzuzeigenden alle signifikanten Ziffern der beiden Double 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 Double 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 das Ergebnis der Multiplikation.1 von 10 und Hinzufügen von.1 Zeiten anzeigen.

    Wenn die Genauigkeit der numerischen Operationen Teilwerte wichtig ist, können Sie mithilfe der Decimal anstelle der Double 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 nicht mit der ursprünglichen Gleitkommazahl stimmt. Der Roundtrip kann fehlschlagen, da eine oder mehrere Ziffern verloren oder eine Konvertierung geändert werden. Im folgenden Beispiel drei Double Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert werden. Ausgabe allerdings zeigt, obwohl die Werte werden identisch, sind die wiederhergestellten Werte ungleich auf die ursprünglichen Werte.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.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.17821782178218 <> 2.17821782178218
    //       0.333333333333333 <> 0.333333333333333
    //       3.14159265358979 <> 3.14159265358979
    

    In diesem Fall die Werte kann erfolgreich Roundtrip mithilfe der "R" Standardformatzeichenfolge die vollständige Genauigkeit beibehalten Double Werte, wie im folgenden Beispiel gezeigt.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.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.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
  • 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, das Ergebnis identisch Divisionsoperationen zugewiesen ist ein Double und ein 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 anstelle von der Single -Datentyp, oder verwenden die Round Methode so, dass beide Werte die gleiche Genauigkeit haben.

Darüber hinaus das Ergebnis von arithmetischen Vorgängen und Zuweisungsvorgängen mit Double Werte möglicherweise unterscheiden sich geringfügig von der Plattform aufgrund der Verlust an Genauigkeit von den Double Typ. Z. B. das Ergebnis der Zuweisung eines literalen Double Wert kann in den 32-Bit- und 64-Bit-Versionen von .NET Framework unterscheiden. Das folgende Beispiel veranschaulicht dies Unterschied, wenn das Literal Wert – 4.42330604244772E-305 und eine Variable, deren Wert - 4.42330604244772E-305 zugewiesen sind ein Double Variable. Beachten Sie, dass das Ergebnis der Parse(String) -Methode ist in diesem Fall nicht aus einem Verlust an Genauigkeit beeinträchtigt.

double value = -4.42330604244772E-305;

double fromLiteral = -4.42330604244772E-305;
double fromVariable = value;
double fromParse = Double.Parse("-4.42330604244772E-305");

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral);
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable);
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse);      
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305      

Um als gleich betrachtet werden zwei Double 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 der Unterschiede bei ihrer letzten gültigen 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 Double Werte führen häufig zu unerwarteten Ergebnissen. Dies ist im folgenden Beispiel ersichtlich, in denen gleich zwei anscheinend Double Werte berücksichtigt werden, da die erste 15 Stellen Genauigkeit hat, die zweite 17 erweisen.

using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

Berechnete Werte, die verschiedenen Codepfaden folgen und, unterschiedlich oft bearbeitet, nachweisen berücksichtigt werden. Im folgenden Beispiel ein Double Wert quadriert, und klicken Sie dann die Quadratwurzel berechnet wird, um den ursprünglichen Wert wiederherstellen. Eine zweite Double 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(Double) -Methode gibt an, dass sie nicht gleich sind. Mit der Standardformatzeichenfolge "R" um eine Ergebniszeichenfolge zurückzugeben, die alle signifikanten Ziffern der einzelnen Double-Wert zeigt zeigt an, dass der zweite Wert.0000000000001 ist kleiner als das erste.

using System;

public class Example
{
   public static void Main()
   {
      double value1 = 100.10142;
      value1 = Math.Sqrt(Math.Pow(value1, 2));
      double value2 = Math.Pow(value1 * 3.51, 2);
      value2 = Math.Sqrt(value2) / 3.51;
      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:
//    100.10142 = 100.10142: False
//    
//    100.10142 = 100.10141999999999

In Fällen, in denen ein Verlust an Genauigkeit, die das Ergebnis eines Vergleichs beeinflussen, können Sie eine der folgenden alternativen Aufruf übernehmen 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()
       {
          double value1 = .333333333333333;
          double value2 = 1.0/3;
          int precision = 7;
          value1 = Math.Round(value1, precision);
          value2 = 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 jedoch, dass das Problem der Genauigkeit weiterhin gilt auf die Rundung der Mittelpunkt Werte. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).

  • Ungefähre Gleichheit statt auf Gleichheit. Dies 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

    Double.Epsilon wird manchmal als ein Maß für den Abstand zwischen zwei absolute verwendet Double Werten, wenn Tests auf Gleichheit. Allerdings Double.Epsilon misst den kleinstmöglichen Wert, der hinzugefügt oder davon subtrahiert werden kann ein Double deren Wert 0 (null) ist. Für die meisten Positive und negative Double Werte wird der Wert des Double.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(Double) Methode.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1;
    
          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, .000000001));   
       }
    
       static bool IsApproximatelyEqual(double value1, double value2, double 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 = 0.99999999999999989: False
    //       1 is approximately equal to 0.99999999999999989: True
    

Im Gegensatz zu Operationen mit ganzzahligen Typen, die Ausnahmen bei Überlauf oder ungültige Vorgänge wie z. B. Division durch 0 (null) auslösen, Operationen mit Gleitkommazahlen keine Ausnahmen auslösen. In diesem Fall ist das Ergebnis einer Gleitkommaoperation in Ausnahmefä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 Zahlen, wie im folgenden Beispiel gezeigt multipliziert werden.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
       }
    }
    // The example displays the following output:
    //       1.16328759815342E-225 * 9.1642346778E-175 = 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 Double.MaxValue ist PositiveInfinity, und das Ergebnis einer Operation, die größer sind als Double.MinValue ist NegativeInfinity, wie im folgende Beispiel gezeigt.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Double.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Double.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 einer ungültigen Eingabe. Z. B. durch Aufruf der Math.Sqrt -Methode mit einem negativen Wert gibt NaN, wie Aufrufen der Math.Acos -Methode mit dem Wert, der größer als oder kleiner als eine negative Zahl ist.

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

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

Die Konvertierung des Werts der alle primitiven numerischen Typen an ein Double eine erweiternde Konvertierung wird und daher keine erfordert einen explizite Umwandlungsoperator oder aufrufen, um eine Konvertierungsmethode, wenn sie explizit einen Compiler erfordert. Beispielsweise erfordert der C#-Compiler einen Typumwandlungsoperator für Konvertierungen von Decimal zu Double, während der Visual Basic-Compiler nicht der Fall ist. Im folgenden Beispiel konvertiert die minimalen oder maximalen Wert von anderen primitiven numerischen Typen an ein Double.

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                           Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                           Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                           Single.MinValue, Single.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      double dblValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal))
            dblValue = (Double) value;
         else
            dblValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

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

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

Die Konvertierung einer Double Wert auf einen Wert von einem anderen primitiven numerischen Datentyp ist eine einschränkende Konvertierung und erfordert ein Umwandlungsoperator (in c#), eine Konvertierungsmethode (in Visual Basic) oder einen Aufruf einer Convert Methode. 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.

Single

Single.NegativeInfinity für negative Werte.

Single.PositiveInfinity für positive Werte.

Darüber hinaus Double.NaN, Double.PositiveInfinity, und Double.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 Single, konvertieren sie Sie in Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinity, bzw..

Beachten Sie, dass es sich bei einem Genauigkeitsverlust führen kann, durch Konvertieren einer Double 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 Double 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 Double 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()
   {
      Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
                          12345.6789, 67890.1234, Double.MaxValue,
                          Double.NaN, Double.PositiveInfinity,
                          Double.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);
            }
            try {
                Single sValue = (float) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  sValue, sValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Single.", value);
            }
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

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

Die Double -Struktur und verwandte Typen bieten Methoden zum Ausführen von Vorgängen in den folgenden Bereichen:

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

    Die Double 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 ist. Wenn einer der Operanden einen numerischen Typ, als handelt ein Double, konvertiert ein Double vor dem Vergleich.

    System_CAPS_warningWarnung

    Aufgrund der Unterschiede in der Genauigkeit zwei Double 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 Double 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 und nicht durch implementiert Double Methoden. Wenn einer der Operanden in einer mathematischen Operation einen numerischen Typ, als handelt ein Double, konvertiert ein Double vor dem Ausführen des Vorgangs. Das Ergebnis des Vorgangs ist ebenfalls ein Double Wert.

    Andere mathematischen Operationen ausgeführt werden können, durch Aufrufen von static (Shared in Visual Basic) Methoden in der System.Math Klasse. Es enthält zusätzliche Methoden, die häufig verwendete (z. B. Math.Abs, Math.Sign, und Math.Sqrt), Geometrie (z. B. Math.Cos und Math.Sin), und aus (z. B. Math.Log).

    Sie können auch einzelne Bits in bearbeiten ein Double Wert. Die BitConverter.DoubleToInt64Bits -Methode behält eine Double Wert die Bitmuster in einer 64-Bit-Ganzzahl. Die BitConverter.GetBytes(Double) -Methode gibt die Bitmuster in ein Bytearray zurück.

  • Runden. Rundung wird häufig als eine Technik zum Schädigung von Unterschieden zwischen Probleme gleitkommadarstellung und Genauigkeit. Abrunden einer Double -Wert durch Aufrufen der Math.Round Methode.

  • Formatierung. Sie konvertieren eine Double Wert, der die Zeichenfolgendarstellung durch Aufrufen der ToString -Methode oder mithilfe der Funktion für kombinierte Formatierung. 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 Double 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 Double 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 Typen zu Double Werte. Die Konvertierung eines Werts des standardmäßigen numerischen Typ zu einer Double eine erweiternde Konvertierung wird und nicht, dass der Benutzer von einem Umwandlungsmethode Operator oder Konvertierung

    Allerdings Konvertierung von Int64 und Single Werte können mit einem Genauigkeitsverlust verbunden. In der folgenden Tabelle sind die Unterschiede in der Genauigkeit für die einzelnen Typen aufgeführt:

    Type

    Die maximale Genauigkeit

    Interne Genauigkeit

    Double

    15

    17

    Int64

    19 Dezimalstellen.

    19 Dezimalstellen.

    Single

    7 Dezimalstellen

    9 Dezimalstellen

    Die Genauigkeit am häufigsten Problems Single Werte, die konvertiert werden Double Werte. Im folgenden Beispiel zwei Werte, die, die durch identische Divisionsoperationen sind ungleich, da einer der Werte ist eine Gleitkommazahl mit einfacher Genauigkeit in konvertierten Wert zeigen eine Double.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value = .1;
          Double result1 = value * 10;
          Double result2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             result2 += value;
    
          Console.WriteLine(".1 * 10:           {0:R}", result1);
          Console.WriteLine(".1 Added 10 times: {0:R}", result2);
       }
    }
    // The example displays the following output:
    //       .1 * 10:           1
    //       .1 Added 10 times: 0.99999999999999989
    

Das folgende Codebeispiel veranschaulicht die Verwendung von Double:

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
public class Temperature : IComparable, IFormattable 
   {
	// IComparable.CompareTo implementation.
	public int CompareTo(object obj) {
           if (obj == null) return 1;

		Temperature temp = obj as Temperature;
           if (obj != null) 
			return m_value.CompareTo(temp.m_value);
		else
    			throw new ArgumentException("object is not a Temperature");	
	}

	// IFormattable.ToString implementation.
	public string ToString(string format, IFormatProvider provider) {
		if( format != null ) {
			if( format.Equals("F") ) {
				return String.Format("{0}'F", this.Value.ToString());
			}
			if( format.Equals("C") ) {
				return String.Format("{0}'C", this.Celsius.ToString());
			}
		}

		return m_value.ToString(format, provider);
	}

	// Parses the temperature from a string in the form
	// [ws][sign]digits['F|'C][ws]
	public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
		Temperature temp = new Temperature();

		if( s.TrimEnd(null).EndsWith("'F") ) {
			temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
		}
		else if( s.TrimEnd(null).EndsWith("'C") ) {
			temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
		}
		else {
			temp.Value = Double.Parse(s, styles, provider);
		}

		return temp;
	}

	// The value holder
	protected double m_value;

	public double Value {
		get {
			return m_value;
		}
		set {
			m_value = value;
		}
	}

	public double Celsius {
		get {
			return (m_value-32.0)/1.8;
		}
		set {
			m_value = 1.8*value+32.0;
		}
	}
}

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.

System_CAPS_cautionAchtung

Eine Instanz dieses Typs zuordnen ist nicht auf allen Hardwareplattformen threadsicher, da die binäre Darstellung der Instanz möglicherweise zu groß, um in einem einzigen Vorgang zuweisen.

Zurück zum Anfang
Anzeigen:
© 2016 Microsoft