Double Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.

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

public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattable

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

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

[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

type double = struct
    interface IConvertible
    interface ISpanFormattable
    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, IComparable(Of Double), IConvertible, IEquatable(Of Double), ISpanFormattable

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 ISpanFormattable

Beispiele

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 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 negativem 1,79769313486232e308 und positivem 1,79769313486232e308 sowie positiven oder negativen Nullen, PositiveInfinity , und keiner Zahl ( ) NegativeInfinity NaN reichen. Es soll Werte darstellen, die extrem groß (z. B. Entfernungen zwischen Planeten oder Galxies) oder extrem klein (z. B. die durchlässige Massen eines Gesundheitswesens in Denkarten) sind und oft unpräzise sind (z. B. die Entfernung von der Erde zu einem anderen Sonnensystem). Der Double Typ entspricht dem IEC 60559:1989-Standard (IEEE 754) für binäre Gleitkommaarithmetik.

Dieses Thema enthält folgende Abschnitte:

• Gleitkommadarstellung und Genauigkeit

• Testen auf Gleichheit

• Gleitkommawerte und Ausnahmen

• Typkonvertierungen und die Double-Struktur

• Gleitkommafunktionen

Floating-Point Darstellung und Genauigkeit

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

Teil	Bits
Mantisse oder Mantisse	0-51
Exponent	52-62
Vorzeichen (0 = Positiv, 1 = Negativ)	63

Ebenso wie Dezimalbruchzahlen einige Bruchwerte nicht genau darstellen können (z. B. 1/3 oder Math.PI ), können binäre Bruchzahlen einige Bruchwerte nicht darstellen. Beispielsweise wird 1/10, das genau durch .1 als Dezimalbruch dargestellt wird, durch .001100110011 als binärer Bruch dargestellt, wobei das Muster "0011" sich bis unendlich wiederholt. In diesem Fall stellt der Gleitkommawert eine unpräzise Darstellung der Zahl bereit, die er darstellt. Das Ausführen zusätzlicher mathematischer Operationen für den ursprünglichen Gleitkommawert führt häufig dazu, dass die Genauigkeit nicht erhöht wird. Wenn wir beispielsweise das Ergebnis der Multiplikation von .1 mit 10 vergleichen und 0,1 bis 0,1 neun Mal hinzufügen, sehen wir, dass die Addition, da sie acht weitere Vorgänge umfasst, das weniger genaue Ergebnis erzeugt hat. Beachten Sie, dass diese Ungleichheit nur offensichtlich ist, wenn wir die beiden Double Werte mithilfe der standardmäßigen numerischen Formatzeichenfolge"R" anzeigen, die bei Bedarf alle 17 Vom Typ unterstützten Genauigkeitsziffern Double anzeigt.

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 genau als binäre Bruchwerte dargestellt werden können, können Gleitkommazahlen nur reelle Zahlen nähern.

Alle Gleitkommazahlen verfügen auch über eine begrenzte Anzahl signifikanter Ziffern, die auch bestimmen, wie genau ein Gleitkommawert einer reellen Zahl entspricht. Ein Double Wert weist eine Genauigkeit von bis zu 15 Dezimalstellen auf, obwohl intern maximal 17 Ziffern beibehalten werden. Dies bedeutet, dass bei einigen Gleitkommavorgängen möglicherweise die Genauigkeit zum Ändern eines Gleitkommawerts fehlt. Dies wird im folgenden Beispiel veranschaulicht. Sie definiert einen sehr großen Gleitkommawert und fügt dann das Produkt Double.Epsilon von und einen Quadrillion hinzu. Das Produkt ist jedoch zu klein, um den ursprünglichen Gleitkommawert zu ändern. Die am wenigsten signifikante Ziffer ist Tausendstel, während die signifikanteste Ziffer im Produkt 10^-309ist.

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 eingeschränkte Genauigkeit einer Gleitkommazahl hat mehrere Folgen:

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

  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 Formatelemente in der Console.WriteLine(String, Object, Object) -Anweisung von {0} und in {1} und {0:R} ändern, um alle {1:R} signifikanten Ziffern der beiden Werte Double anzuzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeitsverlusts während der Additionsvorgänge ungleich sind. In diesem Fall kann das Problem gelöst werden, indem die -Methode aufgerufen Math.Round(Double, Int32) wird, um die Double Werte vor dem Vergleich auf die gewünschte Genauigkeit zu runden.

• Eine mathematische oder Vergleichsoperation, die eine Gleitkommazahl verwendet, liefert möglicherweise nicht das gleiche Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht der Dezimalzahl entspricht. In einem vorherigen Beispiel wurde dies veranschaulicht, indem das Ergebnis der Multiplikation von .1 mit 10 und dem Hinzufügen von .1-Mal angezeigt wurde.

  Wenn genauigkeit in numerischen Vorgängen mit Bruchwerten wichtig ist, können Sie anstelle Decimal des Double Typs verwenden. Wenn die Genauigkeit in numerischen Vorgängen mit ganzzahligen Werten über den Bereich der Int64 Typen oder hinaus wichtig UInt64 ist, verwenden Sie den BigInteger -Typ.

• Ein Wert wird möglicherweise nicht roundtript, wenn eine Gleitkommazahl beteiligt ist. Ein Wert wird als Roundtrip bezeichnet, wenn ein Vorgang eine ursprüngliche Gleitkommazahl in ein anderes Formular konvertiert, ein umgekehrter Vorgang das konvertierte Formular zurück in eine Gleitkommazahl transformiert und die endgültige Gleitkommazahl ungleich der ursprünglichen Gleitkommazahl ist. Der Roundtrip schlägt möglicherweise fehl, da mindestens eine der am wenigsten signifikanten Ziffern bei einer Konvertierung verloren geht oder geändert wird. Im folgenden Beispiel werden drei Double Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert. Wie die Ausgabe zeigt, sind die wiederhergestellten Werte nicht gleich den ursprünglichen Werten, obwohl die Werte identisch zu sein scheinen.

  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 mithilfe der numerischen Standardformatzeichenfolge "G17" gerundet werden, um die vollständige Genauigkeit der Double Werte beizubehalten, 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: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
  

Wichtig

Bei Verwendung mit einem Double -Wert kann der Formatbezeichner "R" in einigen Fällen den ursprünglichen Wert nicht erfolgreich roundtripen. DoubleVerwenden Sie den Formatbezeichner "G17", um sicherzustellen, dass die Werte erfolgreich gerundet werden.

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

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

  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 anstelle Double des Single Datentyps oder die Round -Methode, damit beide Werte die gleiche Genauigkeit aufweisen.

Darüber hinaus kann sich das Ergebnis von arithmetischen und Zuweisungsvorgängen mit Double Werten aufgrund des Genauigkeitsverlusts des Typs je nach Plattform geringfügig Double unterscheiden. Das Ergebnis der Zuweisung eines Literalwerts kann sich beispielsweise Double in den 32-Bit- und 64-Bit-Versionen der .NET Framework unterscheiden. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn der Literalwert -4,42330604244772E-305 und eine Variable mit dem Wert -4,42330604244772E-305 einer Variablen zugewiesen Double werden. Beachten Sie, dass das Ergebnis der Parse(String) -Methode in diesem Fall nicht von einem Genauigkeitsverlust betroffen ist.

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 Gleichheit

Um als gleich betrachtet zu werden, müssen zwei Double Werte identische Werte darstellen. Aufgrund von Unterschieden bei der Genauigkeit zwischen Werten oder aufgrund eines Genauigkeitsverlusts um einen oder beide Werte werden Gleitkommawerte, die voraussichtlich identisch sind, aufgrund der Unterschiede in den am wenigsten signifikanten Ziffern häufig als ungleich angezeigt. Daher führen Aufrufe der Equals -Methode, um zu bestimmen, ob zwei Werte gleich sind, oder Aufrufe der CompareTo -Methode, um die Beziehung zwischen zwei Werten zu Double bestimmen, häufig zu unerwarteten Ergebnissen. Dies wird im folgenden Beispiel deutlich, bei dem sich zwei scheinbar identische Double Werte als ungleich erweisen, da die erste 15 Ziffern genauigkeit auf hat, während die zweite 17 hat.

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

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 ein Genauigkeitsverlust wahrscheinlich auf das Ergebnis eines Vergleichs auswirkt, können Sie eine der folgenden Alternativen zum Aufrufen der - Equals oder CompareTo -Methode übernehmen:

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

  using System;
  
  public class Example
  {
     public static void Main()
     {
        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
  

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

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

  Warnung

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

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

  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 Ausnahmen

Im Gegensatz zu Vorgängen mit ganzzahligen Typen, die Ausnahmen bei Überlauf- oder unzulässigen Vorgängen wie division durch Null auslösen, werden bei Vorgängen mit Gleitkommawerten keine Ausnahmen ausgelöst. In Ausnahmesituationen ist das Ergebnis einer Gleitkommaoperation stattdessen null, positiv 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 multipliziert werden, wie im folgenden Beispiel gezeigt.

  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 eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, ist das Ergebnis des Vorgangs PositiveInfinity oder , je nach NegativeInfinity Vorzeichen des Ergebnisses. Das Ergebnis eines Vorgangs, der Double.MaxValue überläuft, ist , und das Ergebnis eines PositiveInfinity Vorgangs, der Double.MinValue überläuft, ist , wie im folgenden Beispiel NegativeInfinity 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
  

  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 ergibt sich auch aus einer Division durch 0 (null) mit einem positiven Dividend und NegativeInfinity aus einer Division durch 0 (null) mit einem negativen Dividend.

• Wenn ein Gleitkommavorgang ungültig ist, ist das Ergebnis des Vorgangs NaN . Beispielsweise NaN ergibt sich aus den folgenden Vorgängen:

  • Division durch 0 (null) mit einem Dividend von 0 (null). Beachten Sie, dass andere Fälle der Division durch 0 entweder PositiveInfinity oder NegativeInfinity ergeben.

• Alle Gleitkomma-Vorgänge mit einer ungültigen Eingabe. Beispielsweise gibt der Aufruf der Math.Sqrt -Methode mit einem negativen Wert NaN zurück, ebenso wie das Aufrufen der Math.Acos -Methode mit einem Wert, der größer als ein oder kleiner als ein negativer Wert ist.

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

Typkonvertierungen und die Double-Struktur

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

Die Konvertierung des Werts eines beliebigen primitiven numerischen Typs in eine Double ist eine erweiternde Konvertierung und erfordert daher keinen expliziten Umwandlungsoperator oder Aufruf einer Konvertierungsmethode, es sei denn, ein Compiler erfordert dies explizit. Beispielsweise erfordert der C#-Compiler einen Umwandlungsoperator für Konvertierungen von Decimal in , während der Visual Basic Compiler Double dies nicht tut. Im folgenden Beispiel wird der Mindest- oder Höchstwert anderer primitiver numerischer Typen in einen Double konvertiert.

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)

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

Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in einen Double Wert zu einem Genauigkeitsverlust führen kann. Wie das Beispiel veranschaulicht, ist ein Genauigkeitsverlust beim Konvertieren von -, - Decimal Int64 und UInt64 -Werten in Double -Werte möglich.

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

Zieltyp	Ergebnis
Beliebiger ganzzahligen Typ	Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext erfolgt. Wenn die Konvertierung in einem nicht überprüften Kontext erfolgt (der Standardwert in C#), ist der Konvertierungsvorgang erfolgreich, aber der Wert überläuft.
Decimal	Eine OverflowException-Ausnahme.
Single	Single.NegativeInfinity für negative Werte. Single.PositiveInfinity für positive Werte.

Darüber hinaus Double.NaN löst , und eine für Double.PositiveInfinity Double.NegativeInfinity OverflowException Konvertierungen in ganze Zahlen in einem überprüften Kontext aus, aber diese Werte überlaufen, wenn sie in einen nicht überprüften Kontext in ganze Zahlen konvertiert werden. Bei Konvertierungen in Decimal wird immer eine OverflowException ausgelöst. Konvertierung in Single, sie konvertieren in Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinitybzw.

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

Im folgenden Beispiel wird eine Reihe von Double Werten in mehrere andere numerische Typen konvertiert. Die Konvertierungen erfolgen in einem überprüften Kontext in Visual Basic (Standardeinstellung) und in C# (aufgrund des checked-Schlüsselworts). Die Ausgabe des Beispiels zeigt das Ergebnis für Konvertierungen in einem überprüften und nicht überprüften Kontext. Sie können Konvertierungen in einem nicht überprüften Kontext in Visual Basic ausführen, indem Sie mit dem Compilerschalter kompilieren /removeintchecks+ und in C# die checked -Anweisung auskommentieren.

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 Tabellen .NET Framework und Typkonvertierung.

Floating-Point-Funktionalität

Die Double Struktur und die zugehörigen Typen stellen Methoden zum Ausführen von Vorgängen in den folgenden Bereichen bereit:

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

  Die Double -Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Beispielsweise können Sie auf Gleichheit oder Ungleichheit testen oder bestimmen, ob ein Wert größer oder gleich einem anderen wert ist. Wenn einer der Operanden ein anderer numerischer Typ als Double ist, wird er vor dem Vergleich in einen Double konvertiert.

  Warnung

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

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

• Mathematische Operationen. Allgemeine arithmetische Operationen wie Addition, Subtraktion, Multiplikation und Division werden von Sprachcompilern und CIL-Anweisungen (Common Intermediate Language) anstelle von Double Methoden implementiert. Wenn einer der Operanden in einer mathematischen Operation ein anderer numerischer Typ als Double ist, wird er vor dem Ausführen des Vorgangs in einen Double konvertiert. Das Ergebnis des Vorgangs ist auch ein Double -Wert.

  Andere mathematische Operationen können ausgeführt werden, indem static ( Shared in Visual Basic) Methoden in der -Klasse aufgerufen System.Math werden. Sie enthält zusätzliche Methoden, die häufig für arithmetische (z. B. Math.Abs , und ), Geometrie Math.Sign Math.Sqrt (z. B. Math.Cos und ) und Math.Sin Berechnungen (z. Math.Log B. ) verwendet werden.

  Sie können auch die einzelnen Bits in einem Double Wert bearbeiten. Die -Methode behält das BitConverter.DoubleToInt64Bits Bitmuster eines Double Werts in einer 64-Bit-Ganzzahl bei. Die BitConverter.GetBytes(Double) Methode gibt ihr Bitmuster in einem Bytearray zurück.

• Rundung von. Rundung wird häufig als Technik verwendet, um die Auswirkungen von Unterschieden zwischen Werten zu verringern, die durch Probleme bei gleitkommabasierter Darstellung und Genauigkeit verursacht werden. Sie können einen Double Wert runden, indem Sie die Math.Round -Methode aufrufen.

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

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

• Typkonvertierung. Die Double -Struktur stellt eine explizite Schnittstellenimplementierung für die IConvertible -Schnittstelle bereit, die die Konvertierung zwischen zwei standard .NET Framework Datentypen unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten aller anderen numerischen Standardtypen in Double Werte. Die Konvertierung eines Werts eines beliebigen numerischen Standardtyps in eine Double ist eine erweiternde Konvertierung und erfordert nicht den Benutzer eines Umwandlungsoperators oder einer Konvertierungsmethode.

  Die Konvertierung von - und -Werten kann jedoch Int64 zu einem Single Genauigkeitsverlust führen. In der folgenden Tabelle sind die Unterschiede bei der Genauigkeit für jeden dieser Typen aufgeführt:

  Typ	Maximale Genauigkeit	Interne Genauigkeit
  Double	15	17
  Int64	19 Dezimalstellen	19 Dezimalstellen
  Single	7 Dezimalstellen	9 Dezimalstellen

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

  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

Epsilon	Stellt den kleinsten positiven Double-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.
MaxValue	Stellt den größtmöglichen Wert von Double dar. Dieses Feld ist konstant.
MinValue	Stellt den kleinstmöglichen Wert von Double dar. Dieses Feld ist konstant.
NaN	Stellt einen Wert dar, der keine Zahl ist (NaN). Dieses Feld ist konstant.
NegativeInfinity	Stellt minus unendlich dar. Dieses Feld ist konstant.
PositiveInfinity	Stellt plus unendlich dar. Dieses Feld ist konstant.

Methoden

CompareTo(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.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
Equals(Double)	Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Double-Objekt den gleichen Wert darstellen.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetTypeCode()	Gibt den TypeCode für den Werttyp Double zurück.
IsFinite(Double)	Diese Methode bestimmt, ob der Wert endlich ist (Null, subnormal oder normal).
IsInfinity(Double)	Gibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.
IsNaN(Double)	Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl ist (NaN).
IsNegative(Double)	Bestimmt, ob der angegebene Wert negativ ist.
IsNegativeInfinity(Double)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl minus unendlich ergibt.
IsNormal(Double)	Bestimmt, ob der angegebene Wert normal ist.
IsPositiveInfinity(Double)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.
IsSubnormal(Double)	Bestimmt, ob der angegebene Wert subnormal ist.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Doppelinstanz in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Char>, Double)	Konvertiert die Spannendarstellung 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.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Konvertiert eine Zeichenspanne mit der 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.
TryParse(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.
TryParse(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.

Operatoren

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

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)	Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
IConvertible.GetTypeCode()	Gibt den TypeCode für diese Instanz zurück.
IConvertible.ToBoolean(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDateTime(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

Threadsicherheit

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

Siehe auch

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