Double Struktur

Definition

public value class Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

public value class Double : IComparable, IConvertible, IFormattable

public value class Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable

public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

public struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable

type double = struct
    interface IConvertible
    interface IFormattable

[<System.Serializable>]
type double = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
    interface IFormattable
    interface IConvertible

type double = struct
    interface IFormattable

Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattable

Public Structure Double
Implements IComparable, IConvertible, IFormattable

Public Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable

Vererbung

Object

ValueType

Double

Attribute

SerializableAttribute ComVisibleAttribute

Implementiert

IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable

Beispiele

Im folgenden Codebeispiel wird die Verwendung von veranschaulicht Double :The following code example illustrates the use of Double:

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double 
// implementation.
public ref class Temperature: public IComparable, public IFormattable
{
   // IComparable.CompareTo implementation.
public:
   virtual int CompareTo( Object^ obj )
   {
      if (obj == nullptr) return 1;
      
      if (dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException( "object is not a Temperature" );
   }

   // IFormattable.ToString implementation.
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         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]
   static Temperature^ Parse( String^ s, NumberStyles styles, IFormatProvider^ provider )
   {
      Temperature^ temp = gcnew Temperature;

      if ( s->TrimEnd(nullptr)->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      if ( s->TrimEnd(nullptr)->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      {
         temp->Value = Double::Parse( s, styles, provider );
      }
      return temp;
   }

protected:
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }

      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }

      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

// 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;
        }
    }
}

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd(Nothing).EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

Hinweise

Der Double Werttyp stellt eine 64-Bit-Zahl mit doppelter Genauigkeit dar, deren Werte zwischen negativer 1.79769313486232 E308 und positiv 1.79769313486232 E308 liegen, sowie positive oder negative Null, PositiveInfinity , NegativeInfinity und keine Zahl ( NaN ).The Double value type represents a double-precision 64-bit number with values ranging from negative 1.79769313486232e308 to positive 1.79769313486232e308, as well as positive or negative zero, PositiveInfinity, NegativeInfinity, and not a number (NaN). Er soll Werte darstellen, die sehr groß sind (z. b. Entfernungen zwischen Planeten oder Galaxien) oder extrem klein sind (z. b. die molekulare Masse eines Stoffs in Kilo Meter) und häufig unpräzise sind (z. b. die Entfernung von der Erde zu einem anderen Sonnensystem).It is intended to represent values that are extremely large (such as distances between planets or galaxies) or extremely small (such as the molecular mass of a substance in kilograms) and that often are imprecise (such as the distance from earth to another solar system). Der- Double Typ entspricht dem IEC 60559:1989 (IEEE 754)-Standard für binäre Gleit Komma Arithmetik.The Double type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

Dieses Thema enthält folgende Abschnitte:This topic consists of the following sections:

• Darstellung und Genauigkeit von Gleit Komma WertenFloating-point representation and precision

• Testen auf GleichheitTesting for equality

• Gleit Komma Werte und-AusnahmenFloating-point values and exceptions

• Typkonvertierungen und die Double-StrukturType conversions and the Double structure

• Gleit Komma FunktionenFloating-point functionality

Floating-Point Darstellung und GenauigkeitFloating-Point Representation and Precision

Der- Double Datentyp speichert Gleit Komma Werte mit doppelter Genauigkeit in einem 64-Bit-Binärformat, wie in der folgenden Tabelle dargestellt:The Double data type stores double-precision floating-point values in a 64-bit binary format, as shown in the following table:

Ebenso wie dezimale Bruchteile nicht exakt einige Bruchwerte darstellen können (z. b. 1/3 oder Math.PI ), können binäre Bruchteile einige Bruchzahlen nicht darstellen.Just as decimal fractions are unable to precisely represent some fractional values (such as 1/3 or Math.PI), binary fractions are unable to represent some fractional values. Beispielsweise wird 1/10, der genau von 1 als Dezimal Bruch dargestellt wird, durch. 001100110011 als binärer Bruchteil dargestellt, wobei das Muster "0011" in unendlich wiederholt wird.For example, 1/10, which is represented precisely by .1 as a decimal fraction, is represented by .001100110011 as a binary fraction, with the pattern "0011" repeating to infinity. In diesem Fall stellt der Gleit Komma Wert eine ungenaue Darstellung der Zahl dar, die er darstellt.In this case, the floating-point value provides an imprecise representation of the number that it represents. Das Ausführen zusätzlicher mathematischer Operationen für den ursprünglichen Gleit Komma Wert neigt häufig dazu, den Mangel an Genauigkeit zu erhöhen.Performing additional mathematical operations on the original floating-point value often tends to increase its lack of precision. Wenn wir beispielsweise das Ergebnis der Multiplikation von 1 bis 10 und das Addieren von 1 bis 1 9 mal vergleichen, sehen wir, dass das Hinzufügen, da es acht weitere Vorgänge umfasste, das weniger genaue Ergebnis erzeugt hat.For example, if we compare the result of multiplying .1 by 10 and adding .1 to .1 nine times, we see that addition, because it has involved eight more operations, has produced the less precise result. Beachten Sie, dass diese Differenz nur offensichtlich ist, wenn die beiden Double Werte mit der standardmäßigen numerischen Format Zeichenfolge"R" angezeigt werden, die ggf. alle 17 Ziffern der Genauigkeit anzeigt, die vom-Typ unterstützt werden Double .Note that this disparity is apparent only if we display the two Double values by using the "R" standard numeric format string, which if necessary displays all 17 digits of precision supported by the Double type.

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

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

Da einige Zahlen nicht exakt als binäre Binär Werte dargestellt werden können, können Gleit Komma zahlen nur in Bezug auf reelle Zahlen stehen.Because some numbers cannot be represented exactly as fractional binary values, floating-point numbers can only approximate real numbers.

Alle Gleit Komma Zahlen verfügen auch über eine begrenzte Anzahl signifikanter Ziffern, die außerdem bestimmen, wie genau ein Gleit Komma Wert einer reellen Zahl entspricht.All floating-point numbers also have a limited number of significant digits, which also determines how accurately a floating-point value approximates a real number. Ein Double Wert kann bis zu 15 Dezimalstellen der Genauigkeit haben, obwohl intern höchstens 17 Ziffern aufbewahrt werden.A Double value has up to 15 decimal digits of precision, although a maximum of 17 digits is maintained internally. Dies bedeutet, dass einige Gleit Komma Vorgänge möglicherweise nicht die Genauigkeit zum Ändern eines Gleit Komma Werts haben.This means that some floating-point operations may lack the precision to change a floating point value. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration. Dabei wird ein sehr großer Gleit Komma Wert definiert, und anschließend wird das Produkt von Double.Epsilon und einem vierwertigen Wert hinzugefügt.It defines a very large floating-point value, and then adds the product of Double.Epsilon and one quadrillion to it. Das Produkt ist jedoch zu klein, um den ursprünglichen Gleit Komma Wert zu ändern.The product, however, is too small to modify the original floating-point value. Die am wenigsten bedeutende Ziffer ist Tausendstel, wohingegen die signifikanteste Ziffer im Produkt 10^-309ist.Its least significant digit is thousandths, whereas the most significant digit in the product is 10^-309.

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

Module Example
   Public Sub Main()
      Dim value As Double = 123456789012.34567
      Dim additional As Double = Double.Epsilon * 1e15
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional)
   End Sub
End Module
' The example displays the following output:
'   123456789012.346 + 4.94065645841247E-309 = 123456789012.346

Die begrenzte Genauigkeit einer Gleit Komma Zahl hat mehrere folgen:The limited precision of a floating-point number has several consequences:

• Zwei Gleitkommazahlen, die für eine bestimmte Genauigkeit identisch zu sein scheinen, können sich als unterschiedlich erweisen, wenn sich die zwei letzten Ziffern unterscheiden.Two floating-point numbers that appear equal for a particular precision might not compare equal because their least significant digits are different. Im folgenden Beispiel wird eine Reihe von Zahlen addiert, und ihr Gesamtwert wird mit dem erwarteten Gesamtwert verglichen.In the following example, a series of numbers are added together, and their total is compared with their expected total. Obwohl die beiden Werte gleich sind, Equals gibt ein aufrufungsmethode an, dass Sie nicht gleich sind.Although the two values appear to be the same, a call to the Equals method indicates that they are not.

  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).
  

  Module Example
     Public Sub Main()
        Dim values() As Double = { 10.0, 2.88, 2.88, 2.88, 9.0 }
        Dim result As Double = 27.64
        Dim total As Double
        For Each value In values
           total += value
        Next
        If total.Equals(result) Then
           Console.WriteLine("The sum of the values equals the total.")
        Else
           Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                             total, result) 
        End If     
     End Sub
  End Module
  ' The example displays the following output:
  '      The sum of the values (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 Format Elemente in der Console.WriteLine(String, Object, Object) Anweisung von {0} und in {1} ändern {0:R} und {1:R} alle wichtigen Ziffern der beiden Double Werte anzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeits Verlusts bei den Additions Vorgängen ungleich sind.If you change the format items in the Console.WriteLine(String, Object, Object) statement from {0} and {1} to {0:R} and {1:R} to display all significant digits of the two Double values, it is clear that the two values are unequal because of a loss of precision during the addition operations. In diesem Fall kann das Problem gelöst werden, indem Sie die- Math.Round(Double, Int32) Methode aufrufen, um die Double Werte auf die gewünschte Genauigkeit zu runden, bevor Sie den Vergleich durchführen.In this case, the issue can be resolved by calling the Math.Round(Double, Int32) method to round the Double values to the desired precision before performing the comparison.

• Eine mathematische oder Vergleichsoperation, die eine Gleit Komma Zahl verwendet, ergibt möglicherweise nicht dasselbe Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleit Komma Zahl möglicherweise nicht mit der Dezimalzahl übereinstimmt.A mathematical or comparison operation that uses a floating-point number might not yield the same result if a decimal number is used, because the binary floating-point number might not equal the decimal number. Im vorherigen Beispiel wurde dies veranschaulicht, indem das Ergebnis der Multiplikation von 1 bis 10 und das Hinzufügen von. 1 Mal angezeigt wurde.A previous example illustrated this by displaying the result of multiplying .1 by 10 and adding .1 times.

  Wenn die Genauigkeit in numerischen Vorgängen mit Bruch Werten wichtig ist, können Sie Decimal anstelle des- Double Typs verwenden.When accuracy in numeric operations with fractional values is important, you can use the Decimal rather than the Double type. Wenn die Genauigkeit in numerischen Vorgängen mit ganzzahligen Werten außerhalb des Bereichs der Int64 UInt64 Typen oder wichtig ist, verwenden Sie den- BigInteger Typ.When accuracy in numeric operations with integral values beyond the range of the Int64 or UInt64 types is important, use the BigInteger type.

• Ein Wert ist möglicherweise kein Roundtrip, wenn eine Gleit Komma Zahl beteiligt ist.A value might not round-trip if a floating-point number is involved. Ein Wert wird als Roundtrip bezeichnet, wenn ein Vorgang eine ursprüngliche Gleit Komma Zahl in ein anderes Format konvertiert, ein umgekehrter Vorgang das konvertierte Formular wieder in eine Gleit Komma Zahl umwandelt und die abschließende Gleit Komma Zahl nicht der ursprünglichen Gleit Komma Zahl entspricht.A value is said to round-trip if an operation converts an original floating-point number to another form, an inverse operation transforms the converted form back to a floating-point number, and the final floating-point number is not equal to the original floating-point number. Der Roundtrip kann fehlschlagen, weil mindestens eine signifikante Ziffer verloren geht oder bei einer Konvertierung geändert wird.The round trip might fail because one or more least significant digits are lost or changed in a conversion. Im folgenden Beispiel werden drei Werte in Zeichen folgen Double konvertiert und in einer Datei gespeichert.In the following example, three Double values are converted to strings and saved in a file. Wie die Ausgabe zeigt, sind die wiederhergestellten Werte jedoch nicht mit den ursprünglichen Werten identisch, obwohl die Werte als identisch angezeigt werden.As the output shows, however, even though the values appear to be identical, the restored values are not equal to the original values.

  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
  

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

  In diesem Fall können die Werte erfolgreich mit der standardmäßigen numerischen Format Zeichenfolge "G17" abgerundet werden, um die vollständige Genauigkeit der Double Werte beizubehalten, wie im folgenden Beispiel gezeigt.In this case, the values can be successfully round-tripped by using the "G17" standard numeric format string to preserve the full precision of Double values, as the following example shows.

  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:G17}{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
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write("{0:G17}{1}", values(ctr), 
                    If(ctr < values.Length - 1, "|", ""))
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.17821782178218 = 2.17821782178218
  '       0.333333333333333 = 0.333333333333333
  '       3.14159265358979 = 3.14159265358979
  

• Single Werte haben weniger Genauigkeit als Double Werte.Single values have less precision than Double values. Ein Single Wert, der in eine scheinbar Äquivalente konvertiert wird, ist Double Double aufgrund von Genauigkeits unterschieden oft nicht gleich dem Wert.A Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. Im folgenden Beispiel wird das Ergebnis von identischen Divisions Vorgängen einem Double und einem-Wert zugewiesen Single .In the following example, the result of identical division operations is assigned to a Double and a Single value. Nachdem der Single Wert in einen umgewandelt Double wurde, zeigt ein Vergleich der beiden Werte, dass Sie ungleich sind.After the Single value is cast to a Double, a comparison of the two values shows that they are unequal.

  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
  

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

  Um dieses Problem zu vermeiden, verwenden Sie entweder den Double anstelle des- Single Datentyps, oder verwenden Sie die- Round Methode, sodass beide Werte dieselbe Genauigkeit aufweisen.To avoid this problem, use either the Double in place of the Single data type, or use the Round method so that both values have the same precision.

Außerdem kann sich das Ergebnis von arithmetischen und Zuweisungs Vorgängen mit Double Werten aufgrund des Verlusts der Genauigkeit des Typs leicht durch die Plattform unterscheiden Double .In addition, the result of arithmetic and assignment operations with Double values may differ slightly by platform because of the loss of precision of the Double type. Das Ergebnis der Zuweisung eines Literalwerts kann sich beispielsweise Double in den 32-Bit-und 64-Bit-Versionen der .NET Framework unterscheiden.For example, the result of assigning a literal Double value may differ in the 32-bit and 64-bit versions of the .NET Framework. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn der Literalwert-4.42330604244772 e-305 und eine Variable, deren Wert-4.42330604244772 e-305 ist, einer Variablen zugewiesen werden Double .The following example illustrates this difference when the literal value -4.42330604244772E-305 and a variable whose value is -4.42330604244772E-305 are assigned to a Double variable. Beachten Sie, dass das Ergebnis der- Parse(String) Methode in diesem Fall bei einem Genauigkeits Verlust nicht beeinträchtigt wird.Note that the result of the Parse(String) method in this case does not suffer from a loss of precision.

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

Dim value As Double = -4.42330604244772E-305

Dim fromLiteral As Double = -4.42330604244772E-305
Dim fromVariable As Double = value
Dim fromParse As Double = 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      

Testen auf GleichheitTesting for Equality

Um als gleich betrachtet zu werden, Double müssen zwei Werte identische Werte darstellen.To be considered equal, two Double values must represent identical values. Aufgrund von Unterschieden in der Genauigkeit zwischen Werten oder aufgrund eines Genauigkeits Verlusts durch einen oder beide Werte werden Gleit Komma Werte, die als identisch erwartet werden, aufgrund von Unterschieden in den am wenigsten wichtigen Ziffern oft als ungleich fest.However, because of differences in precision between values, or because of a loss of precision by one or both values, floating-point values that are expected to be identical often turn out to be unequal because of differences in their least significant digits. Dies führt dazu, dass Aufrufe der- Equals Methode bestimmen, ob zwei Werte gleich sind, oder Aufrufe an die- CompareTo Methode, um die Beziehung zwischen zwei Werten zu bestimmen Double , was häufig zu unerwarteten Ergebnissen führt.As a result, calls to the Equals method to determine whether two values are equal, or calls to the CompareTo method to determine the relationship between two Double values, often yield unexpected results. Dies ist im folgenden Beispiel ersichtlich, in dem zwei scheinbar gleichwertige Werte sich als ungleich erweisen, Double da der erste 15 Ziffern der Genauigkeit aufweist, während der zweite über 17 Zeichen verfügt.This is evident in the following example, where two apparently equal Double values turn out to be unequal because the first has 15 digits of precision, while the second has 17.

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

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

Berechnete Werte, die auf unterschiedliche Codepfade folgen und auf unterschiedliche Weise bearbeitet werden, werden oft als ungleich feststellen.Calculated values that follow different code paths and that are manipulated in different ways often prove to be unequal. Im folgenden Beispiel Double ist ein Wert quadratisch, und dann wird die Quadratwurzel berechnet, um den ursprünglichen Wert wiederherzustellen.In the following example, one Double value is squared, and then the square root is calculated to restore the original value. Eine zweite Double wird mit 3,51 und quadriert, bevor die Quadratwurzel des Ergebnisses durch 3,51 geteilt wird, um den ursprünglichen Wert wiederherzustellen.A second Double is multiplied by 3.51 and squared before the square root of the result is divided by 3.51 to restore the original value. Obwohl die beiden Werte als identisch angezeigt werden, Equals(Double) weist ein aufrufungsmethode darauf hin, dass Sie nicht gleich sind.Although the two values appear to be identical, a call to the Equals(Double) method indicates that they are not equal. Wenn Sie die Standardformat Zeichenfolge "R" verwenden, um eine Ergebnis Zeichenfolge zurückzugeben, die alle signifikanten Ziffern jedes doppelten Werts anzeigt, wird angezeigt, dass der zweite Wert .0000000000001 kleiner als der erste Wert ist.Using the "R" standard format string to return a result string that displays all the significant digits of each Double value shows that the second value is .0000000000001 less than the first.

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

Module Example
   Public Sub Main()
      Dim value1 As Double = 100.10142
      value1 = Math.Sqrt(Math.Pow(value1, 2))
      Dim value2 As Double = Math.Pow(value1 * 3.51, 2)
      value2 = Math.Sqrt(value2) / 3.51
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:R} = {1:R}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'    100.10142 = 100.10142: False
'    
'    100.10142 = 100.10141999999999

In Fällen, in denen sich der Genauigkeits Verlust wahrscheinlich auf das Ergebnis eines Vergleichs auswirkt, können Sie eine der folgenden Alternativen zum Aufrufen der-oder-Methode übernehmen Equals CompareTo :In cases where a loss of precision is likely to affect the result of a comparison, you can adopt any of the following alternatives to calling the Equals or CompareTo method:

• Wenden Sie die- Math.Round Methode an, um sicherzustellen, dass beide Werte dieselbe Genauigkeit aufweisen.Call the Math.Round method to ensure that both values have the same precision. Im folgenden Beispiel wird ein vorheriges Beispiel dahingehend geändert, dass diese Vorgehensweise verwendet wird, damit zwei Dezimalzahlen gleichwertig sind.The following example modifies a previous example to use this approach so that two fractional values are equivalent.

  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
  

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

  Beachten Sie jedoch, dass das Genauigkeits Problem weiterhin für die Rundung von Mittelpunkt Werten gilt.Note, though, that the problem of precision still applies to rounding of midpoint values. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).For more information, see the Math.Round(Double, Int32, MidpointRounding) method.

• Testen Sie auf ungefähre Gleichheit anstatt auf Gleichheit.Test for approximate equality rather than equality. Dies erfordert, dass Sie einen absoluten Betrag definieren, um den sich die beiden Werte unterscheiden können, aber dennoch gleich sind, oder dass Sie einen relativen Betrag definieren, um den der kleinere Wert vom größeren Wert abweichen kann.This requires that you define either an absolute amount by which the two values can differ but still be equal, or that you define a relative amount by which the smaller value can diverge from the larger value.

  Warnung

  Double.Epsilon wird manchmal als absolutes Maß der Entfernung zwischen zwei Double Werten beim Testen auf Gleichheit verwendet.Double.Epsilon is sometimes used as an absolute measure of the distance between two Double values when testing for equality. Misst jedoch Double.Epsilon den kleinsten möglichen Wert, der einem hinzugefügt oder von diesem subtrahiert werden kann, Double dessen Wert 0 (null) ist.However, Double.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Double whose value is zero. Bei den meisten positiven und negativen Double Werten ist der Wert von Double.Epsilon zu klein, um erkannt zu werden.For most positive and negative Double values, the value of Double.Epsilon is too small to be detected. Mit Ausnahme von Werten, die 0 (null) sind, empfiehlt es sich daher nicht, die Verwendung in Tests auf Gleichheit zu übernehmen.Therefore, except for values that are zero, we do not recommend its use in tests for equality.

  Im folgenden Beispiel wird der letztere Ansatz verwendet, um eine-Methode zu definieren IsApproximatelyEqual , die den relativen Unterschied zwischen zwei Werten testet.The following example uses the latter approach to define an IsApproximatelyEqual method that tests the relative difference between two values. Außerdem wird das Ergebnis von Aufrufen der IsApproximatelyEqual -Methode und der-Methode als gegenübersteht Equals(Double) .It also contrasts the result of calls to the IsApproximatelyEqual method and the Equals(Double) method.

  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
  

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

Floating-Point Werte und AusnahmenFloating-Point Values and Exceptions

Anders als bei Vorgängen mit ganzzahligen Typen, die Ausnahmen bei Überlauf-oder unzulässigen Vorgängen auslösen, wie z. b. Division durch Null, lösen Vorgänge mit Gleit Komma Werten keine Ausnahmen aus.Unlike operations with integral types, which throw exceptions in cases of overflow or illegal operations such as division by zero, operations with floating-point values do not throw exceptions. Stattdessen ist in Ausnahmefällen das Ergebnis einer Gleit Komma Operation 0 (null), positiv unendlich, minus unendlich oder keine Zahl (NaN):Instead, in exceptional situations, the result of a floating-point operation is zero, positive infinity, negative infinity, or not a number (NaN):

• Wenn das Ergebnis einer Gleit Komma Operation für das Zielformat zu klein ist, ist das Ergebnis 0 (null).If the result of a floating-point operation is too small for the destination format, the result is zero. Dies kann vorkommen, wenn zwei sehr kleine Zahlen multipliziert werden, wie im folgenden Beispiel gezeigt.This can occur when two very small numbers are multiplied, as the following example shows.

  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
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1.1632875981534209e-225
        Dim value2 As Double = 9.1642346778e-175
        Dim result As Double = value1 * value2
        Console.WriteLine("{0} * {1} = {2}", value1, value2, result)
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0))
     End Sub
  End Module
  ' The example displays the following output:
  '       1.16328759815342E-225 * 9.1642346778E-175 = 0
  '       0 = 0: True
  

• Wenn die Größe des Ergebnisses einer Gleit Komma Operation den Bereich des Ziel Formats überschreitet, ist das Ergebnis des Vorgangs PositiveInfinity oder NegativeInfinity , je nach dem Vorzeichen des Ergebnisses.If the magnitude of the result of a floating-point operation exceeds the range of the destination format, the result of the operation is PositiveInfinity or NegativeInfinity, as appropriate for the sign of the result. Das Ergebnis eines Vorgangs, der Double.MaxValue überläuft, PositiveInfinity und das Ergebnis eines Vorgangs, der Double.MinValue überläuft, ist NegativeInfinity , wie im folgenden Beispiel gezeigt.The result of an operation that overflows Double.MaxValue is PositiveInfinity, and the result of an operation that overflows Double.MinValue is NegativeInfinity, as the following example shows.

  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
  

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

  PositiveInfinity Dies ergibt auch Ergebnisse aus einer Division durch 0 (null) mit einer positiven Dividende und NegativeInfinity Ergebnisse aus einer Division durch 0 (null) mit einer negativen Dividende.PositiveInfinity also results from a division by zero with a positive dividend, and NegativeInfinity results from a division by zero with a negative dividend.

• Wenn ein Gleit Komma Vorgang ungültig ist, ist das Ergebnis des Vorgangs NaN .If a floating-point operation is invalid, the result of the operation is NaN. NaNDie Ergebnisse der folgenden Vorgänge sind z. b.:For example, NaN results from the following operations:

  • Division durch 0 (null) mit einer Dividende von NULL.Division by zero with a dividend of zero. Beachten Sie, dass andere Fälle der Division durch Null zu PositiveInfinity oder führen NegativeInfinity .Note that other cases of division by zero result in either PositiveInfinity or NegativeInfinity.

• Eine beliebige Gleit Komma Operation mit einer ungültigen Eingabe.Any floating-point operation with an invalid input. Das Aufrufen der- Math.Sqrt Methode mit einem negativen Wert gibt z NaN . b. zurück, ebenso wie das Aufrufen der- Math.Acos Methode mit einem Wert, der größer als 1 oder kleiner als minus eins ist.For example, calling the Math.Sqrt method with a negative value returns NaN, as does calling the Math.Acos method with a value that is greater than one or less than negative one.

• Jeder Vorgang mit einem Argument, dessen Wert ist Double.NaN .Any operation with an argument whose value is Double.NaN.

Typkonvertierungen und die Double-StrukturType conversions and the Double structure

Die- Double Struktur definiert keine expliziten oder impliziten Konvertierungs Operatoren; stattdessen werden Konvertierungen vom Compiler implementiert.The Double structure does not define any explicit or implicit conversion operators; instead, conversions are implemented by the compiler.

Die Konvertierung des Werts eines beliebigen primitiven numerischen Typs in eine Double ist eine erweiternde Konvertierung und erfordert daher keinen expliziten Umwandlungs Operator oder einen aufzurufenden Umwandlungs Methode, es sei denn, ein Compiler erfordert dies explizit.The conversion of the value of any primitive numeric type to a Double is a widening conversion and therefore does not require an explicit cast operator or call to a conversion method unless a compiler explicitly requires it. Der c#-Compiler benötigt z. b. einen Umwandlungs Operator für Konvertierungen von Decimal in Double , während der Visual Basic-Compiler dies nicht tut.For example, the C# compiler requires a casting operator for conversions from Decimal to Double, while the Visual Basic compiler does not. Im folgenden Beispiel wird der minimale oder maximale Wert anderer primitiver numerischer Typen in eine konvertiert Double .The following example converts the minimum or maximum value of other primitive numeric types to a 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)

Module Example
   Public Sub Main()
      Dim values() As Object = { 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 }
      Dim dblValue As Double
      For Each value In values
         dblValue = value
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
      Next
   End Sub
End Module
' 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)

Außerdem werden die Werte, und in Single Single.NaN Single.PositiveInfinity Single.NegativeInfinity Double.NaN , Double.PositiveInfinity Double.NegativeInfinity bzw. konvertiert.In addition, the Single values Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in einen- Double Wert zu einem Genauigkeits Verlust führen kann.Note that the conversion of the value of some numeric types to a Double value can involve a loss of precision. Wie das Beispiel veranschaulicht, ist ein Genauigkeits Verlust möglich, wenn die Decimal Werte von, Int64 und in-Werte umgerechnet werden UInt64 Double .As the example illustrates, a loss of precision is possible when converting Decimal, Int64, and UInt64 values to Double values.

Die Konvertierung eines Double Werts in einen Wert eines beliebigen anderen primitiven numerischen Datentyps ist eine einschränkende Konvertierung und erfordert einen Umwandlungs Operator (in c#), eine Konvertierungsmethode (in Visual Basic) oder einen Convert Methoden aufzurufen.The conversion of a Double value to a value of any other primitive numeric data type is a narrowing conversion and requires a cast operator (in C#), a conversion method (in Visual Basic), or a call to a Convert method. Werte, die sich außerhalb des Bereichs des Ziel Datentyps befinden, der durch die-Eigenschaft und die-Eigenschaft des Zieltyps definiert wird MinValue MaxValue , Verhalten sich wie in der folgenden Tabelle gezeigt.Values that are outside the range of the target data type, which are defined by the target type's MinValue and MaxValue properties, behave as shown in the following table.

Außerdem lösen, Double.NaN Double.PositiveInfinity und Double.NegativeInfinity einen OverflowException für Konvertierungen in ganze Zahlen in einem überprüften Kontext aus, diese Werte überschreiten jedoch bei der Konvertierung in ganze Zahlen in einem nicht überprüften Kontext einen Überlauf.In addition, Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity throw an OverflowException for conversions to integers in a checked context, but these values overflow when converted to integers in an unchecked context. Für Konvertierungen in lösen Decimal Sie immer eine aus OverflowException .For conversions to Decimal, they always throw an OverflowException. Konvertierung in Single, sie konvertieren in Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinitybzw.For conversions to Single, they convert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

Beachten Sie, dass ein Genauigkeits Verlust möglicherweise durch das wandeln eines Double Werts in einen anderen numerischen Typ verursacht wird.Note that a loss of precision may result from converting a Double value to another numeric type. Bei der Umstellung auf einen ganzzahligen Typ, wie die Ausgabe des Beispiels zeigt, geht die Dezimalstelle verloren, wenn der Double Wert entweder gerundet (wie in Visual Basic) oder abgeschnitten (wie in c#) ist.In the case of converting to any of the integral types, as the output from the example shows, the fractional component is lost when the Double value is either rounded (as in Visual Basic) or truncated (as in C#). Für Konvertierungen in Decimal -und- Single Werte Double hat der Wert möglicherweise keine genaue Darstellung im Ziel Datentyp.For conversions to Decimal and Single values, the Double value may not have a precise representation in the target data type.

Im folgenden Beispiel wird eine Anzahl von Double Werten in mehrere andere numerische Typen konvertiert.The following example converts a number of Double values to several other numeric types. Die Konvertierungen erfolgen in einem überprüften Kontext in Visual Basic (Standardeinstellung) und in c# (aufgrund des geprüften Schlüssel Worts).The conversions occur in a checked context in Visual Basic (the default) and in C# (because of the checked keyword). Die Ausgabe aus dem Beispiel zeigt das Ergebnis für Konvertierungen in einem überprüften, nicht überprüften Kontext.The output from the example shows the result for conversions in both a checked an unchecked context. Sie können Konvertierungen in einem nicht überprüften Kontext in Visual Basic ausführen, indem Sie mit dem /removeintchecks+ Compilerschalter kompilieren und in c#, indem Sie die-Anweisung auskommentieren checked .You can perform conversions in an unchecked context in Visual Basic by compiling with the /removeintchecks+ compiler switch and in C# by commenting out the checked statement.

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)

Module Example
   Public Sub Main()
      Dim values() As Double = { Double.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Double.MaxValue,
                                 Double.NaN, Double.PositiveInfinity,
                                 Double.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Int64 = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try
         Try
             Dim sValue As Single = CSng(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               sValue, sValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Single.", value)
         End Try
         Console.WriteLine()
      Next
   End Sub
End Module
' 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) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (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) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (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 numerischer Typen finden Sie unter Typkonvertierung in den .NET Framework -und Typkonvertierungs Tabellen.For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

Floating-Point-FunktionalitätFloating-Point Functionality

Die Double Struktur und die zugehörigen Typen bieten Methoden zum Ausführen von Vorgängen in den folgenden Bereichen:The Double structure and related types provide methods to perform operations in the following areas:

• Vergleich von-Werten.Comparison of values. Sie können die- Equals Methode aufzurufen, um zu bestimmen, ob zwei Double Werte gleich sind, oder die- CompareTo Methode, um die Beziehung zwischen zwei Werten zu bestimmen.You can call the Equals method to determine whether two Double values are equal, or the CompareTo method to determine the relationship between two values.

  Die Double Struktur unterstützt auch einen kompletten Satz von Vergleichs Operatoren.The Double structure also supports a complete set of comparison operators. Beispielsweise können Sie auf Gleichheit oder Ungleichheit testen oder feststellen, ob ein Wert größer oder gleich einem anderen Wert ist.For example, you can test for equality or inequality, or determine whether one value is greater than or equal to another. Wenn einer der Operanden ein numerischer Typ ist, der nicht eine ist Double , wird er Double vor dem Durchführen des Vergleichs in eine konvertiert.If one of the operands is a numeric type other than a Double, it is converted to a Double before performing the comparison.

  Warnung

  Aufgrund von Unterschieden in der Genauigkeit können sich zwei Werte, die als Double gleich erwartet werden, möglicherweise als ungleich erweisen, was sich auf das Ergebnis des Vergleichs auswirkt.Because of differences in precision, two Double values that you expect to be equal may turn out to be unequal, which affects the result of the comparison. Weitere Informationen zum Vergleichen von zwei Werten finden Sie im Abschnitt Tests für Gleichheit Double .See the Testing for Equality section for more information about comparing two Double values.

  Sie können auch die IsNaN Methoden, IsInfinity , IsPositiveInfinity und IsNegativeInfinity zum Testen auf diese speziellen Werte aufzurufen.You can also call the IsNaN, IsInfinity, IsPositiveInfinity, and IsNegativeInfinity methods to test for these special values.

• Mathematische Vorgänge.Mathematical operations. Allgemeine arithmetische Operationen, z. b. Addition, Subtraktion, Multiplikation und Division, werden von sprach Compilern und Common Intermediate Language-Anweisungen (CIL) anstelle von Double Methoden implementiert.Common arithmetic operations, such as addition, subtraction, multiplication, and division, are implemented by language compilers and Common Intermediate Language (CIL) instructions, rather than by Double methods. Wenn einer der Operanden in einer mathematischen Operation ein numerischer Typ ist, der nicht eine ist Double , wird er Double vor dem Ausführen des Vorgangs in eine konvertiert.If one of the operands in a mathematical operation is a numeric type other than a Double, it is converted to a Double before performing the operation. Das Ergebnis des Vorgangs ist auch ein- Double Wert.The result of the operation is also a Double value.

  Andere mathematische Vorgänge können durch Aufrufen von static ( Shared in Visual Basic)-Methoden in der-Klasse ausgeführt werden System.Math .Other mathematical operations can be performed by calling static (Shared in Visual Basic) methods in the System.Math class. Sie enthält zusätzliche Methoden, die häufig für Arithmetik verwendet werden (z. b. Math.Abs , Math.Sign und Math.Sqrt ), Geometrie (z. b. Math.Cos und Math.Sin ) und ein Kalkül (z Math.Log . b.).It includes additional methods commonly used for arithmetic (such as Math.Abs, Math.Sign, and Math.Sqrt), geometry (such as Math.Cos and Math.Sin), and calculus (such as Math.Log).

  Sie können auch die einzelnen Bits in einem Double Wert bearbeiten.You can also manipulate the individual bits in a Double value. Die BitConverter.DoubleToInt64Bits -Methode behält Double das Bitmuster eines Werts in einer 64-Bit-Ganzzahl bei.The BitConverter.DoubleToInt64Bits method preserves a Double value's bit pattern in a 64-bit integer. Die- BitConverter.GetBytes(Double) Methode gibt das Bitmuster in einem Bytearray zurück.The BitConverter.GetBytes(Double) method returns its bit pattern in a byte array.

• Rundung.Rounding. Die Rundung wird häufig als Technik zum Verringern der Auswirkung von Unterschieden zwischen Werten verwendet, die durch Probleme mit der Gleit Komma Darstellung und-Genauigkeit verursacht werden.Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. Sie können einen Wert Runden, Double indem Sie die- Math.Round Methode aufrufen.You can round a Double value by calling the Math.Round method.

• Formatierung.Formatting. Sie können einen Double Wert in seine Zeichen folgen Darstellung konvertieren, indem Sie die- ToString Methode aufrufen oder die Funktion für die kombinierte Formatierung verwenden.You can convert a Double value to its string representation by calling the ToString method or by using the composite formatting feature. Informationen dazu, wie Format Zeichenfolgen die Zeichen folgen Darstellung von Gleit Komma Werten steuern, finden Sie in den Themen Standard Format Zeichenfolgen für Zahlen und benutzerdefinierte Zahlenformat Zeichenfolgen.For information about how format strings control the string representation of floating-point values, see the Standard Numeric Format Strings and Custom Numeric Format Strings topics.

• Zeichen folgen werden verarbeitet.Parsing strings. Sie können die Zeichen folgen Darstellung eines Gleit Komma Werts in einen-Wert konvertieren, Double indem Sie entweder die-oder die- Parse Methode aufrufen TryParse .You can convert the string representation of a floating-point value to a Double value by calling either the Parse or TryParse method. Wenn der Analyse Vorgang fehlschlägt, löst die Parse Methode eine Ausnahme aus, während die TryParse Methode zurückgibt false .If the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

• Typkonvertierung.Type conversion. Die- Double Struktur stellt eine explizite Schnittstellen Implementierung für die- IConvertible Schnittstelle bereit, die die Konvertierung zwischen zwei Datentypen vom Typ Standard .NET Framework unterstützt.The Double structure provides an explicit interface implementation for the IConvertible interface, which supports conversion between any two standard .NET Framework data types. Sprach Compiler unterstützen auch die implizite Konvertierung von Werten aller anderen numerischen Standardtypen in- Double Werte.Language compilers also support the implicit conversion of values of all other standard numeric types to Double values. Die Konvertierung eines Werts eines beliebigen standardmäßigen numerischen Typs in eine Double ist eine erweiternde Konvertierung, die den Benutzer eines Umwandlungs Operators oder einer Konvertierungsmethode nicht erfordert.Conversion of a value of any standard numeric type to a Double is a widening conversion and does not require the user of a casting operator or conversion method,

  Allerdings kann das Konvertieren von Int64 -und- Single Werten zu einem Genauigkeits Verlust führen.However, conversion of Int64 and Single values can involve a loss of precision. In der folgenden Tabelle sind die Unterschiede in der Genauigkeit für die einzelnen Typen aufgeführt:The following table lists the differences in precision for each of these types:

  TypType	Maximale GenauigkeitMaximum precision	Interne GenauigkeitInternal precision
  Double	1515	1717
  Int64	19 Dezimalziffern19 decimal digits	19 Dezimalziffern19 decimal digits
  Single	7 Dezimalziffern7 decimal digits	9 Dezimalziffern9 decimal digits

  Das Problem der Genauigkeit wirkt sich am häufigsten Single auf Werte aus, die in-Werte konvertiert werden Double .The problem of precision most frequently affects Single values that are converted to Double values. Im folgenden Beispiel sind zwei Werte, die von identischen Divisions Vorgängen erzeugt werden, ungleich, da einer der-Werte ein Gleit Komma Wert mit einfacher Genauigkeit ist, der in eine konvertiert wird Double .In the following example, two values produced by identical division operations are unequal because one of the values is a single-precision floating point value converted to a 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
  

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

Felder

Methoden

Operatoren

Explizite Schnittstellenimplementierungen

Gilt für:

Threadsicherheit

Alle Member dieses Typs sind Thread sicher.All members of this type are thread safe. Member, die scheinbar den Instanzzustand ändern, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde.Members that appear to modify instance state actually return a new instance initialized with the new value. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Thread Sicherheit zu gewährleisten.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

Siehe auch

• Decimal
• Single
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)Sample: .NET Core WinForms Formatting Utility (C#)
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)Sample: .NET Core WinForms Formatting Utility (Visual Basic)