# DoubleDoubleDoubleDouble Struct

## 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``
``````[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable``````
``````type double = struct
interface IFormattable
interface IConvertible``````
``````Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattable``````
Vererbung
DoubleDoubleDoubleDouble
Attribute
Implementiert

## Beispiele

Im folgenden Codebeispiel wird die Verwendung von Doubleveranschaulicht: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 PositiveInfinityNULL 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 (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), der Double der Typ entspricht dem IEC 60559:1989 (IEEE 754)-Standard für binäre Gleit Komma Arithmetik.It is intended to represent values that are extremely large (such as distances between planets or galaxies) or extremely small (the molecular mass of a substance in kilograms) and that often are imprecise (such as the distance from earth to another solar system), The Double type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

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

### Darstellung und Genauigkeit von Gleit Komma WertenFloating-Point Representation and Precision

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:

SegmentPart 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. Math.PI1/3 oder), 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 Double die beiden Werte mit der standardmäßigen numerischen Format Zeichenfolge"R" angezeigt werden, die ggf. alle 17 Double Ziffern der Genauigkeit anzeigt, die vom-Typ unterstützt werden.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 Gleit Komma Zahlen, die für eine bestimmte Genauigkeit gleich angezeigt werden, sind möglicherweise nicht gleich, da sich Ihre geringsten 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, gibt ein `Equals` 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 Console.WriteLine(String, Object, Object) Format Elemente in der Anweisung von `{0}` und `{1}` in `{0:R}` ändern und `{1:R}` alle wichtigen Ziffern der beiden Double Werte anzeigen, ist klar, dass die beiden Werte ungleich sind. ein Genauigkeits Verlust während der Addition.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, Double um die 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 Decimal Genauigkeit in numerischen Vorgängen mit Bruch Werten wichtig ist, können Sie 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 Int64 des UInt64 Bereichs der Typen oder wichtig ist BigInteger , verwenden Sie den-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 dem Original entspricht. Gleit Komma Zahl.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 Double Werte in Zeichen folgen 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 Double Format Bezeichner "G17", um sicherzustellen, dass die Werte erfolgreich durchgeführt werden.To ensure that Double values successfully round-trip, use the "G17" format specifier.

• SingleWerte haben weniger Genauigkeit als Double Werte.Single values have less precision than Double values. Ein Single Wert, der in eine scheinbar äquivalente Double konvertiert wird, ist aufgrund Double 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 Single -Wert zugewiesen.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 Doubleumgewandelt 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 Double entweder den anstelle Single des-Datentyps, Round oder verwenden Sie die-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 Double Vorgängen mit Werten aufgrund des Verlusts der Genauigkeit Double des Typs leicht durch die Plattform unterscheiden.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 Double kann sich beispielsweise 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 Double ist, einer Variablen zugewiesen werden.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 Parse(String) der-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 CompareTo die-Methode, um die Beziehung Double zwischen zwei Werten zu bestimmen, 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 gleich Double wertige Werte sich als ungleich erweisen, 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 ist ein Double 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, weist ein Equals(Double) 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 Equals - CompareTo oder-Methode übernehmen: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 Math.Round die-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.Epsilonwird 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 den kleinsten möglichen Wert, der einem Double hinzugefügt oder von diesem subtrahiert werden kann, dessen Wert 0 (null) ist. Double.EpsilonHowever, 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 Double negativen Werten ist der Wert Double.Epsilon von 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 `IsApproximatelyEqual` eine-Methode zu definieren, 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 `IsApproximatelyEqual` der-Methode und der Equals(Double) -Methode als gegenübersteht.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
``````

### Gleit Komma 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 PositiveInfinity das Ergebnis des Vorgangs 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, Double.MaxValue der ü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
``````

PositiveInfinityDies ergibt auch Ergebnisse aus einer Division durch 0 (null) mit NegativeInfinity einer positiven Dividende und 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 NaNdas Ergebnis des Vorgangs.If a floating-point operation is invalid, the result of the operation is NaN. Die Ergebnisse der NaN 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, Math.Acos ebenso wie das Aufrufen der-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 Double.NaNist.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 Decimal Konvertierungen von 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 Doubleeine konvertiert.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)
``````

Darüber hinaus die Single Werte Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinity konvertieren, Double.NaN, Double.PositiveInfinity, und Double.NegativeInfinitybzw.In addition, the Single values Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity covert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in Double einen-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, Decimalwenn die SingleWerte, UInt64 Int64, und Double in-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 Double eines Werts in einen Wert eines beliebigen anderen primitiven numerischen Datentyps ist eine einschränkende Konvertierung und erfordert einen Umwandlungs C#Operator (in), eine Konvertierungsmethode (in Visual Basic) oder Convert einen-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 `MinValue` und `MaxValue` die-Eigenschaft des Zieltyps definiert wird, 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 erfolgt (der C#Standardwert in), 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.NegativeInfinityfür negative Werte.Single.NegativeInfinity for negative values.

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

Außerdem Double.NaN OverflowException lösen, undDouble.NegativeInfinity einen 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. Double.PositiveInfinityIn 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 Decimalin lösen Sie immer eine OverflowExceptionaus.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 Double durch das wandeln eines 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 Double ganzzahlige Werte konvertiert werden, wie die Ausgabe aus dem Beispiel zeigt, geht die Bruchteil-Komponente verloren, wenn der Double Wert entweder gerundet (wie in Visual Basic) oder abgeschnitten ist (wie in C#).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 Decimal in Single -und- Double Werte 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) C# und in (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, `/removeintchecks+` indem Sie mit dem C# -Compilerschalter `checked` kompilieren und in die-Anweisung auskommentieren.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.

### Gleit Komma FunktionenFloating-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 Double zu bestimmen, ob zwei Werte CompareTo gleich sind, oder die-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 Doubleeine ist, wird er vor Double 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 Double können sich zwei Werte, die als 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 Double Werten finden Sie im Abschnitt Tests für Gleichheit .See the Testing for Equality section for more information about comparing two Double values.

Sie IsNaNkönnen auch die Methoden, IsInfinity, IsPositiveInfinityund 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 Double von 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 Doubleeine ist, wird er vor Double 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 `static` von (`Shared` in Visual Basic)-Methoden in der System.Math -Klasse ausgeführt werden.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 Math.Abswerden Math.Sign(z Math.Sqrt. b., und) Math.Cos , Math.SinGeometrie (z. b. und Math.Log) und ein Kalkül (z. 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 Double Wert Runden, indem Sie Math.Round die-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 ToString Sie die-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 Double -Wert konvertieren, indem Sie entweder die-oder TryParse die Parse -Methode aufrufen.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 Parse die Methode eine Ausnahme aus, während TryParse die Methode `false`zurückgibt.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 IConvertible die-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 Double eine 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 Int64 konvertieren Single von-und-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 Single sich am häufigsten auf Werte aus, die in Double -Werte konvertiert werden.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 Doubleist, der in eine konvertiert wird.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

 Epsilon Epsilon Epsilon Epsilon 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. MaxValue MaxValue MaxValue MaxValue 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. MinValue MinValue MinValue MinValue Stellt den kleinstmöglichen Wert von Double dar.Represents the smallest possible value of a Double. Dieses Feld ist konstant.This field is constant. NaN NaN NaN NaN 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. NegativeInfinity NegativeInfinity NegativeInfinity NegativeInfinity Stellt minus unendlich dar.Represents negative infinity. Dieses Feld ist konstant.This field is constant. PositiveInfinity PositiveInfinity PositiveInfinity PositiveInfinity Stellt plus unendlich dar.Represents positive infinity. Dieses Feld ist konstant.This field is constant.

## Operatoren

 Equality(Double, Double) Equality(Double, Double) Equality(Double, Double) Equality(Double, Double) 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. GreaterThan(Double, Double) GreaterThan(Double, Double) GreaterThan(Double, Double) GreaterThan(Double, Double) 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. GreaterThanOrEqual(Double, Double) GreaterThanOrEqual(Double, Double) GreaterThanOrEqual(Double, Double) 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.Returns a value that indicates whether a specified Double value is greater than or equal to another specified Double value. Inequality(Double, Double) Inequality(Double, Double) Inequality(Double, Double) Inequality(Double, Double) 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. LessThan(Double, Double) LessThan(Double, Double) LessThan(Double, Double) LessThan(Double, Double) 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. LessThanOrEqual(Double, Double) LessThanOrEqual(Double, Double) LessThanOrEqual(Double, Double) LessThanOrEqual(Double, Double) 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

 IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider). IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider). IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(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. IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(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 IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider). IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider). IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider). IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider). IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider). IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider). IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider). IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider). IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider). IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider). IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

## Gilt für:

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