Double Struktur

Definition

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
Double
Attribute
Implementiert

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 mit Werten im Bereich von 1,79769313486232e308 bis positive 1,79769313486232e308 sowie eine positive oder negative Null, PositiveInfinity , und keine Zahl ( ) NegativeInfinity NaN dar. Es soll Werte darstellen, die extrem groß (z. B. Abstände zwischen Planeten oder Antexen) oder extrem klein (z. B. die wässrige Massen eines Gesundheitswesens in Denkarten) sind und häufig unpräzise sind (z. B. die Entfernung von der Erde zu einem anderen Sonnensystem). Der Double Typ entspricht dem STANDARD IEC 60559:1989 (IEEE 754) für binäre Gleitkommaarithmetik.

Dieses Thema enthält folgende Abschnitte:

Floating-Point Darstellung und Genauigkeit

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

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

Ebenso wie Dezimalbruchzahlen einige Bruchwerte (z. B. 1/3 oder ) nicht genau darstellen können, 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 erhöht häufig die Fehlende Genauigkeit. 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 von signifikanten Ziffern, die auch bestimmen, wie genau ein Gleitkommawert eine reelle Zahl annähert. 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 wird, Math.Round(Double, Int32) um die Werte vor dem Vergleich auf die gewünschte Genauigkeit zu Double runden.

  • Ein mathematischer Vorgang oder ein Vergleichsvorgang, der eine Gleitkommazahl verwendet, liefert möglicherweise nicht das gleiche Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht der Dezimalzahl entspricht. In einem vorherigen Beispiel wurde dies veranschaulicht, indem das Ergebnis der Multiplikation von .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. Das folgende Beispiel veranschaulicht diesen Unterschied, 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 Werte als Double 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 geändert, um diesen Ansatz zu verwenden, 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 und nicht auf 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 eines Gleitkommavorgangs 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. Wenn Sie z. B. die Math.Sqrt -Methode mit einem negativen Wert aufrufen, wird NaN zurückgegeben, ebenso wie der Aufruf 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 ist eine sich ausweitende Konvertierung und erfordert daher keinen expliziten Umwandlungsoperator oder Aufruf einer Konvertierungsmethode, es sei denn, ein Compiler erfordert dies Double explizit. Beispielsweise erfordert der C#-Compiler einen Umwandlungsoperator für Konvertierungen von in , während der Visual Basic Decimal Double compiler 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 bzw. Double.NegativeInfinity konvertiert.

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

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

Zieltyp Ergebnis
Beliebiger integraler Typ Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext erfolgt.

Wenn die Konvertierung in einem nicht überprüften Kontext (standard in C#) erfolgt, 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 löst , und eine für 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 Double.NaN Double.PositiveInfinity konvertiert Double.NegativeInfinity OverflowException werden. Bei Konvertierungen in Decimal wird immer eine -Ausnahme OverflowException auslösen. 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 der integralen Typen geht, wie die Ausgabe aus dem Beispiel zeigt, die Bruchkomponente verloren, wenn der Wert entweder gerundet (wie in Visual Basic) oder abgeschnitten Double wird (wie in C#). Bei Konvertierungen in - und -Werte hat Decimal der Wert möglicherweise keine genaue Darstellung im Single Double Zieldatentyp.

Im folgenden Beispiel wird eine Reihe von Werten Double in mehrere andere numerische Typen konvertiert. Die Konvertierungen erfolgen in einem überprüften Kontext in Visual Basic (Standardeinstellung) und in C# (aufgrund des schlüsselwort checked). Die Ausgabe des Beispiels zeigt das Ergebnis für Konvertierungen in einem überprüften kontext. Sie können Konvertierungen in einem nicht überprüften Kontext in Visual Basic, indem Sie mit dem Compilerschalter kompilieren und in C# die Anweisung /removeintchecks+ checked 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 im .NET Framework und Typkonvertierungstabellen.

Floating-Point Funktionalität

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

  • Vergleich der Werte. Sie können die -Methode aufrufen, um zu bestimmen, ob zwei Werte gleich sind, oder die -Methode, um die Beziehung Equals zwischen zwei Werten zu Double CompareTo 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 ist. Wenn einer der Operanden ein anderer numerischer Typ als ist, wird er vor dem Vergleich in Double Double einen konvertiert.

    Warnung

    Aufgrund von Unterschieden bei der Genauigkeit können zwei Werte, die Sie als gleich erwarten, ungleich sein, was sich auf das Ergebnis Double des Vergleichs auswirken kann. Weitere Informationen zum Vergleichen von zwei Werten finden Sie im Abschnitt Testen auf Double Gleichheit.

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

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

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

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

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

  • Formatierung von. Sie können einen Wert Double in seine Zeichenfolgendarstellung konvertieren, indem Sie die -Methode ToString aufrufen oder das Feature für die kombinierte Formatierung verwenden. Informationen dazu, wie Formatzeichenfolgen die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie in den Themen Standard Numeric Format Strings und Custom Numeric Format Strings.

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

  • Typkonvertierung. Die Double -Struktur stellt eine explizite Schnittstellenimplementierung für die -Schnittstelle bereit, die die Konvertierung zwischen zwei beliebigen .NET Framework IConvertible 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 ist eine sich ausweitende Konvertierung und erfordert nicht den Benutzer eines Umwandlungsoperator oder Double einer Konvertierungsmethode.

    Die Konvertierung von - Int64 und Single -Werten kann jedoch zu einem 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 Problem der Genauigkeit 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 nur einer 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).

Gilt für

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