# Double Struktur

## Definition

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.Represents a double-precision floating-point number.

public value class Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
public value class Double : IComparable, IConvertible, IFormattable
public value class Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
public struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable
type double = struct
interface IConvertible
interface IFormattable
[<System.Serializable>]
type double = struct
interface IFormattable
interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
interface IFormattable
interface IConvertible
type double = struct
interface IFormattable
Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattable
Public Structure Double
Implements IComparable, IConvertible, IFormattable
Public Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable
Vererbung
Double
Attribute
Implementiert

## Beispiele

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

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

if (dynamic_cast<Temperature^>(obj) )
{
Temperature^ temp = (Temperature^)(obj);
return m_value.CompareTo( temp->m_value );
}
throw gcnew ArgumentException( "object is not a Temperature" );
}

// IFormattable.ToString implementation.
virtual String^ ToString( String^ format, IFormatProvider^ provider )
{
if ( format != nullptr )
{
if ( format->Equals( "F" ) )
{
return String::Format( "{0}'F", this->Value.ToString() );
}

if ( format->Equals( "C" ) )
{
return String::Format( "{0}'C", this->Celsius.ToString() );
}
}
return m_value.ToString( format, provider );
}

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

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

protected:
double m_value;

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

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

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

void set( double value )
{
m_value = 1.8 * value + 32.0;
}
}
};
// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
public class Temperature : IComparable, IFormattable
{
// IComparable.CompareTo implementation.
public int CompareTo(object obj) {
if (obj == null) return 1;

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

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

return m_value.ToString(format, provider);
}

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

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

return temp;
}

// The value holder
protected double m_value;

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

public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
' Temperature class stores the value as Double
' and delegates most of the functionality
' to the Double implementation.
Public Class Temperature
Implements IComparable, IFormattable

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

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

Return m_value.CompareTo(temp.m_value)
End If

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

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

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

Return m_value.ToString(format, provider)
End Function

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

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

' The value holder
Protected m_value As Double

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

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

## Hinweise

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

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

### Floating-Point Darstellung und GenauigkeitFloating-Point Representation and Precision

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

TeilPart BitsBits
Signifikanor oder MantisseSignificand or mantissa 0-510-51
ExponentExponent 52-6252-62
Vorzeichen (0 = positiv, 1 = negativ)Sign (0 = Positive, 1 = Negative) 6363

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

using System;

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

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

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

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

using System;

public class Example
{
public static void Main()
{
Double value = 123456789012.34567;
Double additional = Double.Epsilon * 1e15;
Console.WriteLine("{0} + {1} = {2}", value, additional,
}
}
// 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,
End Sub
End Module
' The example displays the following output:
'   123456789012.346 + 4.94065645841247E-309 = 123456789012.346

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

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

using System;

public class Example
{
public static void Main()
{
Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 };
Double result = 27.64;
Double total = 0;
foreach (var value in values)
total += value;

if (total.Equals(result))
Console.WriteLine("The sum of the values equals the total.");
else
Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
total, result);
}
}
// The example displays the following output:
//      The sum of the values (36.64) does not equal the total (36.64).
//
// If the index items in the Console.WriteLine statement are changed to {0:R},
// the example displays the following output:
//       The sum of the values (27.639999999999997) does not equal the total (27.64).

Module Example
Public Sub Main()
Dim values() As Double = { 10.0, 2.88, 2.88, 2.88, 9.0 }
Dim result As Double = 27.64
Dim total As Double
For Each value In values
total += value
Next
If total.Equals(result) Then
Console.WriteLine("The sum of the values equals the total.")
Else
Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
total, result)
End If
End Sub
End Module
' The example displays the following output:
'      The sum of the values (36.64) does not equal the total (36.64).
'
' If the index items in the Console.WriteLine statement are changed to {0:R},
' the example displays the following output:
'       The sum of the values (27.639999999999997) does not equal the total (27.64).

Wenn Sie die Format Elemente in der Console.WriteLine(String, Object, Object) Anweisung von {0} und in {1} ändern {0:R} und {1:R} alle wichtigen Ziffern der beiden Double Werte anzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeits Verlusts bei den Additions Vorgängen ungleich sind.If you change the format items in the Console.WriteLine(String, Object, Object) statement from {0} and {1} to {0:R} and {1:R} to display all significant digits of the two Double values, it is clear that the two values are unequal because of a loss of precision during the addition operations. In diesem Fall kann das Problem gelöst werden, indem Sie die- Math.Round(Double, Int32) Methode aufrufen, um die Double Werte auf die gewünschte Genauigkeit zu runden, bevor Sie den Vergleich durchführen.In this case, the issue can be resolved by calling the Math.Round(Double, Int32) method to round the Double values to the desired precision before performing the comparison.

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

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

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

using System;
using System.IO;

public class Example
{
public static void Main()
{
StreamWriter sw = new StreamWriter(@".\Doubles.dat");
Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
for (int ctr = 0; ctr < values.Length; ctr++) {
sw.Write(values[ctr].ToString());
if (ctr != values.Length - 1)
sw.Write("|");
}
sw.Close();

Double[] restoredValues = new Double[values.Length];
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 temp As String = sr.ReadToEnd()
Dim tempStrings() As String = temp.Split("|"c)
For ctr As Integer = 0 To tempStrings.Length - 1
restoredValues(ctr) = Double.Parse(tempStrings(ctr))
Next

For ctr As Integer = 0 To values.Length - 1
Console.WriteLine("{0} {2} {1}", values(ctr),
restoredValues(ctr),
If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
Next
End Sub
End Module
' The example displays the following output:
'       2.17821782178218 <> 2.17821782178218
'       0.333333333333333 <> 0.333333333333333
'       3.14159265358979 <> 3.14159265358979

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

using System;
using System.IO;

public class Example
{
public static void Main()
{
StreamWriter sw = new StreamWriter(@".\Doubles.dat");
Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
for (int ctr = 0; ctr < values.Length; ctr++)
sw.Write("{0:G17}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );

sw.Close();

Double[] restoredValues = new Double[values.Length];
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 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 "R"-Format Bezeichner in einigen Fällen keinen erfolgreichen Roundtrip für den ursprünglichen Wert durchgeführt werden.When used with a Double value, the "R" format specifier in some cases fails to successfully round-trip the original value. Verwenden Sie den Format Bezeichner "G17", um sicherzustellen, dass die Double Werte erfolgreich durchgeführt werden.To ensure that Double values successfully round-trip, use the "G17" format specifier.

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

using System;

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

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

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

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

double value = -4.42330604244772E-305;

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

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

Dim fromLiteral As Double = -4.42330604244772E-305
Dim fromVariable As Double = value
Dim fromParse As Double = Double.Parse("-4.42330604244772E-305")

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

### Testen auf GleichheitTesting for Equality

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

using System;

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

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

using System;

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

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

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

using System;

public class Example
{
public static void Main()
{
double value1 = .333333333333333;
double value2 = 1.0/3;
int precision = 7;
value1 = Math.Round(value1, precision);
value2 = Math.Round(value2, precision);
Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
}
}
// The example displays the following output:
//        0.3333333 = 0.3333333: True

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

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

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

Warnung

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

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

using System;

public class Example
{
public static void Main()
{
double one1 = .1 * 10;
double one2 = 0;
for (int ctr = 1; ctr <= 10; ctr++)
one2 += .1;

Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
one1, one2,
IsApproximatelyEqual(one1, one2, .000000001));
}

static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
{
// If they are equal anyway, just return True.
if (value1.Equals(value2))
return true;

// Handle NaN, Infinity.
if (Double.IsInfinity(value1) | Double.IsNaN(value1))
return value1.Equals(value2);
else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
return value1.Equals(value2);

// Handle zero to avoid division by zero
double divisor = Math.Max(value1, value2);
if (divisor.Equals(0))
divisor = Math.Min(value1, value2);

return Math.Abs((value1 - value2) / divisor) <= epsilon;
}
}
// The example displays the following output:
//       1 = 0.99999999999999989: False
//       1 is approximately equal to 0.99999999999999989: True

Module Example
Public Sub Main()
Dim one1 As Double = .1 * 10
Dim one2 As Double = 0
For ctr As Integer = 1 To 10
one2 += .1
Next
Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
one1, one2,
IsApproximatelyEqual(one1, one2, .000000001))
End Sub

Function IsApproximatelyEqual(value1 As Double, value2 As Double,
epsilon As Double) As Boolean
' If they are equal anyway, just return True.
If value1.Equals(value2) Then Return True

' Handle NaN, Infinity.
If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then
Return value1.Equals(value2)
Else If Double.IsInfinity(value2) Or Double.IsNaN(value2)
Return value1.Equals(value2)
End If

' Handle zero to avoid division by zero
Dim divisor As Double = Math.Max(value1, value2)
If divisor.Equals(0) Then
divisor = Math.Min(value1, value2)
End If

Return Math.Abs((value1 - value2) / divisor) <= epsilon
End Function
End Module
' The example displays the following output:
'       1 = 0.99999999999999989: False
'       1 is approximately equal to 0.99999999999999989: True

### Floating-Point Werte und AusnahmenFloating-Point Values and Exceptions

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

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

using System;

public class Example
{
public static void Main()
{
Double value1 = 1.1632875981534209e-225;
Double value2 = 9.1642346778e-175;
Double result = value1 * value2;
Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
}
}
// The example displays the following output:
//       1.16328759815342E-225 * 9.1642346778E-175 = 0
//       0 = 0: True

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

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

using System;

public class Example
{
public static void Main()
{
Double value1 = 4.565e153;
Double value2 = 6.9375e172;
Double result = value1 * value2;
Console.WriteLine("PositiveInfinity: {0}",
Double.IsPositiveInfinity(result));
Console.WriteLine("NegativeInfinity: {0}\n",
Double.IsNegativeInfinity(result));

value1 = -value1;
result = value1 * value2;
Console.WriteLine("PositiveInfinity: {0}",
Double.IsPositiveInfinity(result));
Console.WriteLine("NegativeInfinity: {0}",
Double.IsNegativeInfinity(result));
}
}

// The example displays the following output:
//       PositiveInfinity: True
//       NegativeInfinity: False
//
//       PositiveInfinity: False
//       NegativeInfinity: True

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

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

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

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

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

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

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

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

using System;

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

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

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

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

ZieltypTarget type ErgebnisResult
Beliebige ganzzahlige TypenAny integral type Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext erfolgt.An OverflowException exception if the conversion occurs in a checked context.

Wenn die Konvertierung in einem nicht überprüften Kontext (der Standard in c#) erfolgt, wird der Konvertierungs Vorgang erfolgreich ausgeführt, der Wert wird jedoch überlaufen.If the conversion occurs in an unchecked context (the default in C#), the conversion operation succeeds but the value overflows.
Decimal Eine OverflowException-Ausnahme.An OverflowException exception.
Single Single.NegativeInfinity für negative Werte.Single.NegativeInfinity for negative values.

Single.PositiveInfinity für positive Werte.Single.PositiveInfinity for positive values.

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

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

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

using System;

public class Example
{
public static void Main()
{
Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
12345.6789, 67890.1234, Double.MaxValue,
Double.NaN, Double.PositiveInfinity,
Double.NegativeInfinity };
checked {
foreach (var value in values) {
try {
Int64 lValue = (long) value;
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
lValue, lValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("Unable to convert {0} to Int64.", value);
}
try {
UInt64 ulValue = (ulong) value;
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
ulValue, ulValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("Unable to convert {0} to UInt64.", value);
}
try {
Decimal dValue = (decimal) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
dValue, dValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("Unable to convert {0} to Decimal.", value);
}
try {
Single sValue = (float) value;
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
sValue, sValue.GetType().Name);
}
catch (OverflowException) {
Console.WriteLine("Unable to convert {0} to Single.", value);
}
Console.WriteLine();
}
}
}
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
Module Example
Public Sub Main()
Dim values() As Double = { Double.MinValue, -67890.1234, -12345.6789,
12345.6789, 67890.1234, Double.MaxValue,
Double.NaN, Double.PositiveInfinity,
Double.NegativeInfinity }
For Each value In values
Try
Dim lValue As Int64 = CLng(value)
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
lValue, lValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Int64.", value)
End Try
Try
Dim ulValue As UInt64 = CULng(value)
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
ulValue, ulValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to UInt64.", value)
End Try
Try
Dim dValue As Decimal = CDec(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
dValue, dValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Decimal.", value)
End Try
Try
Dim sValue As Single = CSng(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
sValue, sValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Single.", value)
End Try
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -1.79769313486232E+308 to Int64.
'       Unable to convert -1.79769313486232E+308 to UInt64.
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.1234 to UInt64.
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       Unable to convert 1.79769313486232E+308 to Int64.
'       Unable to convert 1.79769313486232E+308 to UInt64.
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)

Weitere Informationen zur Konvertierung numerischer Typen finden Sie unter Typkonvertierung in den .NET Framework -und Typkonvertierungs Tabellen.For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

### Floating-Point-FunktionalitätFloating-Point Functionality

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

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

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

Warnung

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

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

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

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

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

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

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

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

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

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

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

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

using System;

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

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

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

## Felder

 Stellt den kleinsten positiven Double-Wert dar, der größer als 0 (null) ist.Represents the smallest positive Double value that is greater than zero. Dieses Feld ist konstant.This field is constant. Stellt den größtmöglichen Wert von Double dar.Represents the largest possible value of a Double. Dieses Feld ist konstant.This field is constant. Stellt den kleinstmöglichen Wert von Double dar.Represents the smallest possible value of a Double. Dieses Feld ist konstant.This field is constant. Stellt einen Wert dar, der keine Zahl ist (NaN).Represents a value that is not a number (NaN). Dieses Feld ist konstant.This field is constant. Stellt minus unendlich dar.Represents negative infinity. Dieses Feld ist konstant.This field is constant. Stellt plus unendlich dar.Represents positive infinity. Dieses Feld ist konstant.This field is constant.

## Methoden

 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.Compares this instance to a specified double-precision floating-point number and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified double-precision floating-point number. 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.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object. Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Double-Objekt den gleichen Wert darstellen.Returns a value indicating whether this instance and a specified Double object represent the same value. Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value indicating whether this instance is equal to a specified object. Gibt den Hashcode für diese Instanz zurück.Returns the hash code for this instance. Gibt den TypeCode für den Werttyp Double zurück.Returns the TypeCode for value type Double. Diese Methode bestimmt, ob der Wert endlich ist (Null, subnormal oder normal).Determines whether the specified value is finite (zero, subnormal, or normal). Gibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.Returns a value indicating whether the specified number evaluates to negative or positive infinity. Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl ist (NaN).Returns a value that indicates whether the specified value is not a number (NaN). Bestimmt, ob der angegebene Wert negativ ist.Determines whether the specified value is negative. Gibt einen Wert zurück, der angibt, ob die angegebene Zahl minus unendlich ergibt.Returns a value indicating whether the specified number evaluates to negative infinity. Bestimmt, ob der angegebene Wert normal ist.Determines whether the specified value is normal. Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.Returns a value indicating whether the specified number evaluates to positive infinity. Bestimmt, ob der angegebene Wert subnormal ist.Determines whether the specified value is subnormal. Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts a character span that contains the string representation of a number in a specified style and culture-specific format to its double-precision floating-point number equivalent. Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number to its double-precision floating-point number equivalent. Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number in a specified culture-specific format to its double-precision floating-point number equivalent. Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number in a specified style to its double-precision floating-point number equivalent. Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number in a specified style and culture-specific format to its double-precision floating-point number equivalent. Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation. Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information. Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.Converts the numeric value of this instance to its equivalent string representation, using the specified format. Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information. Versucht, den Wert der aktuellen Doppelinstanz in die angegebene Zeichenspanne zu formatieren.Tries to format the value of the current double instance into the provided span of characters. Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the span representation of a number in a specified style and culture-specific format to its double-precision floating-point number equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.A return value indicates whether the conversion succeeded or failed. Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts a character span containing the string representation of a number in a specified style and culture-specific format to its double-precision floating-point number equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.A return value indicates whether the conversion succeeded or failed. Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number to its double-precision floating-point number equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.A return value indicates whether the conversion succeeded or failed. Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.Converts the string representation of a number in a specified style and culture-specific format to its double-precision floating-point number equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.A return value indicates whether the conversion succeeded or failed.

## Operatoren

 Gibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte gleich sind.Returns a value that indicates whether two specified Double values are equal. Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer als ein anderer angegebener Double-Wert ist.Returns a value that indicates whether a specified Double value is greater than another specified Double value. Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer oder gleich einem anderen angegebenen Double-Wert ist.Returns a value that indicates whether a specified Double value is greater than or equal to another specified Double value. Gibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte gleich sind.Returns a value that indicates whether two specified Double values are not equal. Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer als ein anderer angegebener Double-Wert ist.Returns a value that indicates whether a specified Double value is less than another specified Double value. Gibt einen Wert zurück, der angibt, ob ein angegebener Double -Wert kleiner oder gleich einem anderen angegebenen Double-Wert ist.Returns a value that indicates whether a specified Double value is less than or equal to another specified Double value.

## Explizite Schnittstellenimplementierungen

 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.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. Gibt den TypeCode für diese Instanz zurück.Returns the TypeCode for this instance. Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider). Diese Konvertierung wird nicht unterstützt.This conversion is not supported. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.Attempting to use this method throws an InvalidCastException. Diese Konvertierung wird nicht unterstützt.This conversion is not supported. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.Attempting to use this method throws an InvalidCastException Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider). Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).