Double Struktúra

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Double.cs

Dupla pontosságú lebegőpontos számot jelöl.

public value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>

public readonly struct Double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>

type double = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<double>
    interface ISpanFormattable
    interface ISpanParsable<double>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<double>
    interface IAdditionOperators<double, double, double>
    interface IAdditiveIdentity<double, double>
    interface IBinaryFloatingPointIeee754<double>
    interface IBinaryNumber<double>
    interface IBitwiseOperators<double, double, double>
    interface IComparisonOperators<double, double, bool>
    interface IEqualityOperators<double, double, bool>
    interface IDecrementOperators<double>
    interface IDivisionOperators<double, double, double>
    interface IIncrementOperators<double>
    interface IModulusOperators<double, double, double>
    interface IMultiplicativeIdentity<double, double>
    interface IMultiplyOperators<double, double, double>
    interface INumber<double>
    interface INumberBase<double>
    interface ISubtractionOperators<double, double, double>
    interface IUnaryNegationOperators<double, double>
    interface IUnaryPlusOperators<double, double>
    interface IExponentialFunctions<double>
    interface IFloatingPointConstants<double>
    interface IFloatingPoint<double>
    interface ISignedNumber<double>
    interface IFloatingPointIeee754<double>
    interface IHyperbolicFunctions<double>
    interface ILogarithmicFunctions<double>
    interface IPowerFunctions<double>
    interface IRootFunctions<double>
    interface ITrigonometricFunctions<double>
    interface IMinMaxValue<double>

Public Structure Double
Implements IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double), IUtf8SpanParsable(Of Double)

Öröklődés

Object

ValueType

Double

Megvalósítás

IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanFormattable ISpanParsable<Double> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<TSelf> IAdditionOperators<Double,Double,Double> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Double,Double> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Double> IBinaryNumber<Double> IBinaryNumber<TSelf> IBitwiseOperators<Double,Double,Double> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Double,Double,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<TSelf> IFloatingPointConstants<Double> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Double> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Double> IHyperbolicFunctions<TSelf> IIncrementOperators<Double> IIncrementOperators<TSelf> ILogarithmicFunctions<Double> ILogarithmicFunctions<TSelf> IMinMaxValue<Double> IModulusOperators<Double,Double,Double> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Double,Double> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Double,Double,Double> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Double> INumber<TSelf> INumberBase<Double> INumberBase<TSelf> IPowerFunctions<Double> IPowerFunctions<TSelf> IRootFunctions<Double> IRootFunctions<TSelf> ISignedNumber<Double> ISignedNumber<TSelf> ISubtractionOperators<Double,Double,Double> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Double> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Double,Double> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Double,Double> IUnaryPlusOperators<TSelf,TSelf>

Példák

Az alábbi példakód a következők használatát szemlélteti Double:

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

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () = (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

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

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        elif s.TrimEnd(null).EndsWith "'C" then
            temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        else
            temp.Value <- Double.Parse(s, styles, provider)
        temp

    interface IComparable with
        // IComparable.CompareTo implementation.
        member this.CompareTo(obj: obj) =
            match obj with 
            | null -> 1
            | :? Temperature as temp ->
                this.Value.CompareTo temp.Value
            | _ ->
                invalidArg "obj" "object is not a Temperature"

    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)

' 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().EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd().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

Megjegyzések

Az Double értéktípus egy dupla pontosságú 64 bites számot jelöl, amelynek értéke negatív 1,79769313486232e308 és pozitív 1,79769313486232e308, valamint pozitív vagy negatív nulla, PositiveInfinityNegativeInfinityés nem szám (NaN). Kifejezetten nagy értékeket (például bolygók vagy galaxisok közötti távolságokat) vagy rendkívül kicsiket (például egy anyag molekulatömegét kilogrammban) jelöl, és amelyek gyakran pontatlanok (például a földtől egy másik naprendszerig). A Double típus megfelel a bináris lebegőpontos számtani IEC 60559:1989 (IEEE 754) szabványnak.

Lebegőpontos ábrázolás és pontosság

Az Double adattípus a két pontosságú lebegőpontos értékeket 64 bites bináris formátumban tárolja, az alábbi táblázatban látható módon:

Rész	Bitek
Matematikai alapszám vagy mantissza	0-51
Exponent	52-62
Jel (0 = Pozitív, 1 = Negatív)	63

Ahogyan a tizedes törtek nem képesek pontosan képviselni bizonyos törtértékeket (például 1/3 vagy Math.PI), a bináris törtek nem képesek bizonyos törtértékeket képviselni. Az 1/10 például, amelyet pontosan .1 tizedes törtként jelöl, a .001100110011 bináris törtként jelenik meg, a "0011" minta pedig a végtelenbe ismétlődik. Ebben az esetben a lebegőpontos érték nem pontos képet ad az általa képviselt számról. Az eredeti lebegőpontos értéken végzett további matematikai műveletek gyakran növelik a pontosság hiányát. Ha például összehasonlítja az .1 és 10 szorzás eredményét, és 0,1-et 9-szer ad hozzá, akkor láthatja, hogy az összeadás, mivel nyolc további műveletet is érintett, a kevésbé pontos eredményt eredményezte. (A 10-es .NET előtt ez az eltérés csak akkor jelenik meg, ha a két Double értéket az "R" standard numerikus formátumú sztring használatával jeleníti meg, amely a Double típus által támogatott 17 számjegyig jeleníti meg a pontosságot.)

using System;

public class Example13
{
    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:           {result1:R}");
        Console.WriteLine($".1 Added 10 times: {result2:R}");
    }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
    result2 <- result2 + value

printfn $".1 * 10:           {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

Module Example14
    Public Sub Run()
        Dim value As Double = 0.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

Mivel egyes számok nem jeleníthetők meg pontosan tört bináris értékekként, a lebegőpontos számok csak a valós számokat tudják megközelíteni.

Az összes lebegőpontos szám is korlátozott számú jelentős számjegyből áll, ami azt is meghatározza, hogy egy lebegőpontos érték mennyire közelíti meg a valós számot. Egy Double érték legfeljebb 15 tizedesjegy pontossággal rendelkezik, de belsőleg legfeljebb 17 számjegy tartható fenn. Ez azt jelenti, hogy egyes lebegőpontos műveletek nem feltétlenül rendelkeznek a lebegőpontos értékek módosításának pontosságával. Az alábbi példa egy illusztrációt tartalmaz. Egy nagyon nagy lebegőpontos értéket határoz meg, majd hozzáadja a Double.Epsilon szorzatát és egy kvadrilliót. A termék azonban túl kicsi az eredeti lebegőpontos érték módosításához. Legkisebb számjegye ezred, míg a termék legjelentősebb számjegye a ^10-309.

using System;

public class Example14
{
    public static void Main()
    {
        Double value = 123456789012.34567;
        Double additional = Double.Epsilon * 1e15;
        Console.WriteLine($"{value} + {additional} = {value + additional}");
    }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

open System

let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

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

A lebegőpontos számok korlátozott pontossága számos következménnyel jár:

• Előfordulhat, hogy két lebegőpontos szám, amely egy adott pontosságnak felel meg, nem hasonlítható össze egyenlővel, mivel a legkisebb jelentős számjegyeik eltérőek. Az alábbi példában egy számsort adunk össze, és az összegük a várt összeggel lesz összehasonlítva.

  using System;
  
  public class Example10
  {
      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 ({total}) does not equal the 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).
  

  let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ]
  let result = 27.64
  let total = List.sum values
  
  if total.Equals result then
      printfn "The sum of the values equals the total."
  else
      printfn $"The sum of the values ({total}) does not equal the 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 Example11
      Public Sub Run()
          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).
  

  A két érték egyenlőtlen, mert az összeadási műveletek során a pontosság elvész. Ebben az esetben a probléma megoldható úgy, hogy az összehasonlítás végrehajtása előtt meghívja a Math.Round(Double, Int32) metódust az Double értékek kívánt pontosságú kerekítésére.

• Előfordulhat, hogy egy lebegőpontos számot használó matematikai vagy összehasonlító művelet nem ugyanazt az eredményt adja, ha decimális számot használ, mert a bináris lebegőpontos szám nem feltétlenül egyenlő a decimális számmal. Ezt egy korábbi példa szemlélteti a .1 és 10 szorzat eredményének megjelenítésével, majd a .1-szeres összeadással.

  Amikor a törtértékekkel rendelkező numerikus műveletek pontossága fontos, a Decimal típus helyett a Double típust használhatja. Ha a típustartományon túli integrálértékekkel rendelkező numerikus műveletek pontossága Int128UInt128 fontos, használja a típust BigInteger .

• Single az értékek pontossága kisebb, mint az Double értékeké. A Single érték, amelyet látszólag egyenértékűvé konvertálnak Double, gyakran nem egyenlő a Double értékkel a pontosságbeli különbségek miatt. Az alábbi példában az azonos osztási műveletek eredménye külön-külön a Double és a Single értékhez van rendelve. Miután az Single értéket egy Doubleértékre öntötte, a két érték összehasonlítása azt mutatja, hogy egyenlőtlenek.

  using System;
  
  public class Example9
  {
      public static void Run()
      {
          double value1 = 1 / 3.0;
          float sValue2 = 1 / 3.0f;
          double value2 = (double)sValue2;
          Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
      }
  }
  
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  open System
  
  let value1 = 1. / 3.
  let sValue2 = 1f /3f
  
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example10
      Public Sub Run()
          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
  

  A probléma elkerülése érdekében használja az Double adattípus helyett Single , vagy használja a Round metódust úgy, hogy mindkét érték ugyanolyan pontosságú legyen.

Emellett az értékekkel végzett Double aritmetikai és hozzárendelési műveletek eredménye platformonként kissé eltérhet a típus pontosságának Double elvesztése miatt. A konstans Double érték hozzárendelésének eredménye például eltérhet a .NET 32 bites és 64 bites verzióiban. Az alábbi példa ezt a különbséget mutatja be, ha a -4.42330604244772E-305 literálérték és a -4.42330604244772E-305 érték egy változóhoz Double van rendelve. Vegye figyelembe, hogy ebben az esetben a Parse(String) módszer eredménye nem szenved a pontosság elvesztésétől.

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

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

let value = -4.42330604244772E-305

let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"

printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// 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.4233060424477198E-305

Dim fromLiteral As Double = -4.4233060424477198E-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)

' 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

Egyenlőség tesztelése

Az egyenlőséghez két Double értéknek azonos értékeket kell jelölnie. Az értékek közötti pontosságbeli különbségek, illetve az egy vagy mindkét érték pontosságának elvesztése miatt azonban a lebegőpontos értékek, amelyek várhatóan azonosak lesznek, gyakran egyenlőtlenek lesznek a legkisebb jelentős számjegyeik különbségei miatt. Ennek eredményeként meghívja a Equals metódust annak megállapítására, hogy két érték egyenlő-e, vagy a metódus meghívása CompareTo a két Double érték közötti kapcsolat meghatározására, gyakran váratlan eredményeket eredményez. Ez nyilvánvaló a következő példában, ahol két látszólag egyenlő Double érték nem egyenlőnek bizonyul, mert az első 15 számjegy pontosságú, míg a második 17 számjegy pontosságú.

using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

open System

let value1 = 0.333333333333333
let value2 = 1. / 3.
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

Module Example1
    Public Sub Run()
        Dim value1 As Double = 0.333333333333333
        Dim value2 As Double = 1 / 3
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module

' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

Azokban az esetekben, amikor a pontosság elvesztése valószínűleg hatással van az összehasonlítás eredményére, a következő alternatívák bármelyikét alkalmazhatja a Equals metódus meghívására CompareTo :

• Hívja meg a Math.Round metódust, hogy mindkét érték azonos pontosságú legyen. Az alábbi példa módosít egy korábbi példát, hogy ezt a megközelítést használja, hogy két törtérték egyenértékű legyen.

  double value1 = .333333333333333;
  double value2 = 1.0 / 3;
  int precision = 7;
  value1 = Math.Round(value1, precision);
  value2 = Math.Round(value2, precision);
  Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
  
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  open System
  
  let v1 = 0.333333333333333
  let v2 = 1. / 3.
  let precision = 7
  let value1 = Math.Round(v1, precision)
  let value2 = Math.Round(v2, precision)
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example3
      Public Sub Run()
          Dim value1 As Double = 0.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} = {1}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  A pontosság problémája továbbra is a középponti értékek kerekítésére vonatkozik. További információkért tekintse meg a metódust Math.Round(Double, Int32, MidpointRounding) .

• Tesztelje a közelítő egyenlőséget az egyenlőség helyett. Ehhez meg kell határoznia egy abszolút összeget, amellyel a két érték eltérhet, de egyenlő lehet, vagy meg kell határoznia egy relatív értéket, amellyel a kisebb érték eltérhet a nagyobb értéktől.

  Warning

  Double.Epsilon néha a két Double érték közötti távolság abszolút mértékeként használják az egyenlőség vizsgálatakor. Azonban Double.Epsilon a legkisebb lehetséges értéket méri, amely Double értékhez adható hozzá vagy vonható ki belőle, aminek az értéke nulla. A legtöbb pozitív és negatív Double érték esetében az érték Double.Epsilon túl kicsi ahhoz, hogy észlelhető legyen. Ezért a nulla értékek kivételével nem javasoljuk az egyenlőségi tesztekben való használatát.

  Az alábbi példa az utóbbi megközelítést használja egy IsApproximatelyEqual olyan módszer meghatározására, amely két érték közötti relatív különbséget teszteli. A módszer a Math.Max(value1, value2)-vel oszt, ezáltal az összehasonlítás a két érték közül a nagyobb (nagyság szerint) értékhez viszonyul, ami az eredményt a megfelelő nagyságrendre helyezi. Ha Math.Max nullát ad vissza (ami akkor fordul elő, ha az egyik érték nulla, a másik negatív), a metódus visszaesik Math.Min(value1, value2) a nem nulla érték osztóként való használatára. Az összehasonlítást az IsApproximatelyEqual metódusra és a Equals(Double) metódusra intézett hívások eredményei is érintik.

  using System;
  
  public class Example3
  {
      public static void Main()
      {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
              one2 += .1;
  
          Console.WriteLine($"{one1} = {one2}: {one1.Equals(one2)}");
          Console.WriteLine($"{one1} is approximately equal to {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
  

  open System
  
  let isApproximatelyEqual (value1: double) (value2: double) (epsilon: double) =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      else
          // Handle NaN, Infinity.
          if Double.IsInfinity value1 || Double.IsNaN value1 then 
              value1.Equals value2
          elif Double.IsInfinity value2 || Double.IsNaN value2 then
              value1.Equals value2
          else
              // Handle zero to avoid division by zero
              let divisor = max value1 value2
              let divisor = 
                  if divisor.Equals 0 then
                      min value1 value2
                  else 
                      divisor
              abs ((value1 - value2) / divisor) <= epsilon
  
  let one1 = 0.1 * 10.
  let mutable one2 = 0.
  for _ = 1 to 10 do
      one2 <- one2 + 0.1
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000000001}"
  
  // The example displays the following output:
  //       1 = 0.99999999999999989: False
  //       1 is approximately equal to 0.99999999999999989: True
  

  Module Example4
      Public Sub Run()
          Dim one1 As Double = 0.1 * 10
          Dim one2 As Double = 0
          For ctr As Integer = 1 To 10
              one2 += 0.1
          Next
          Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0} is approximately equal to {1}: {2}",
                          one1, one2,
                          IsApproximatelyEqual(one1, one2, 0.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)
          ElseIf Double.IsInfinity(value2) Or Double.IsNaN(value2) Then
              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
  

Lebegőpontos értékek és kivételek

Az integrál típusú műveletektől eltérően, amelyek nullával való osztást vagy DivideByZeroException túlcsordulást eredményeznek OverflowException egy ellenőrzött környezetben, a lebegőpontos értékekkel végzett műveletek nem adnak kivételt. Ehelyett kivételes helyzetekben a lebegőpontos művelet eredménye nulla, pozitív végtelen, negatív végtelen vagy nem szám (NaN):

• Ha egy lebegőpontos művelet eredménye túl kicsi a célformátumhoz, az eredmény nulla. Ez akkor fordulhat elő, ha két nagyon kis szám szorozva van, ahogy az alábbi példa is mutatja.

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

  let value1 = 1.1632875981534209e-225
  let value2 = 9.1642346778e-175
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals 0.0}"
  // The example displays the following output:
  //       1.16328759815342E-225 * 9.1642346778E-175 = 0
  //       0 = 0: True
  

  Module Example7
      Public Sub Run()
          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
  

• Ha egy lebegőpontos művelet eredményének nagysága meghaladja a célformátum tartományát, a művelet PositiveInfinity eredménye vagy NegativeInfinityaz eredmény előjelének megfelelő. A Double.MaxValue túlcsorduló művelet eredménye PositiveInfinity, és egy Double.MinValue túlcsorduló művelet eredménye NegativeInfinity, ahogy az alábbi példa mutatja.

  using System;
  
  public class Example7
  {
      public static void Main()
      {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}");
          Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}{Environment.NewLine}");
  
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}");
          Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}");
      }
  }
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  open System
  
  let value1 = 4.565e153
  let value2 = 6.9375e172
  let result = value1 * value2
  printfn $"PositiveInfinity: {Double.IsPositiveInfinity result}"
  printfn $"NegativeInfinity: {Double.IsNegativeInfinity result}\n"
  
  let value3 = - value1
  let result2 = value2 * value3
  printfn $"PositiveInfinity: {Double.IsPositiveInfinity result2}"
  printfn $"NegativeInfinity: {Double.IsNegativeInfinity result2}"
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example8
      Public Sub Run()
          Dim value1 As Double = 4.565E+153
          Dim value2 As Double = 6.9375E+172
          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 pozitív osztalékkal rendelkező nullával történő osztásból is származik, és NegativeInfinity negatív osztalékkal rendelkező nullával való osztás eredménye.

• Ha egy lebegőpontos művelet érvénytelen, a művelet eredménye NaN. Például a NaN következő műveletek eredményei:

  • Osztás nullával nulla osztalékkal. Vegye figyelembe, hogy a nullával való osztás egyéb esetei vagy PositiveInfinity, vagy NegativeInfinity eredményeznek.

  • Bármely lebegőpontos művelet érvénytelen bemenettel. Ha például negatív értékkel hívja meg a Math.Sqrt metódust, az visszaadja NaN-t, ahogy a Math.Acos metódust is visszaadja NaN-t, ha egynél nagyobb vagy mínusz egynél kisebb értékkel hívják meg.

  • Bármely művelet, amelynek argumentuma értéke Double.NaN.

Típuskonverziók

A Double struktúra nem határoz meg explicit vagy implicit konverziós operátorokat, ehelyett a fordításokat a fordító implementálja.

Bármely primitív numerikus típus Double értékének konvertálása szélesítő átalakítás, ezért nem igényel explicit öntött operátort vagy átalakítási metódus meghívását, kivéve, ha egy fordító kifejezetten megköveteli. A C#-fordítóhoz például egy casting operátorra van szükség a Decimal és Double közötti átalakításhoz, míg a Visual Basic fordító nem. Az alábbi példa más primitív numerikus típusok minimális vagy maximális értékét konvertálja Double értékre.

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 (dynamic value in values)
{
    if (value.GetType() == typeof(decimal))
        dblValue = (double)value;
    else
        dblValue = value;
    Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
        $"{dblValue:R} ({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)

open System

let values: obj[] = 
    [| 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 |]

for value in values do
    let dblValue = value :?> double
    printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({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 Example5
    Public Sub Run()
        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)

Emellett a Single, Single.NaN, és Single.PositiveInfinity értékek átalakulnak Single.NegativeInfinity, Double.NaN, és Double.PositiveInfinity értékekké, illetve Double.NegativeInfinity-é.

Vegye figyelembe, hogy bizonyos numerikus típusok értékké Double alakítása a pontosság elvesztésével járhat. Ahogy a példa is mutatja, a pontosságvesztés lehetséges, amikor a Decimal, Int64 és UInt64 értékeket Double értékekké alakítjuk.

A Double érték konvertálása bármely más primitív numerikus adattípus értékére szűkítő konverzió, amelyhez öntött operátor (C#-ban), átalakítási módszerre (Visual Basic) vagy Convert metódus hívására van szükség. A céladattípus tartományán kívül eső értékek, amelyeket a céltípus MinValue és MaxValue a tulajdonságok határoznak meg, az alábbi táblázatban látható módon viselkednek.

Céltípus	Result
Bármilyen integráltípus	Kivétel OverflowException , ha az átalakítás ellenőrzött környezetben történik. Ha az átalakítás nem ellenőrzött környezetben történik (az alapértelmezett C#-ban), a konvertálási művelet sikeres, de az érték túlcsordul.
Decimal	Egy kivétel OverflowException.
Single	Single.NegativeInfinity negatív értékek esetén. Single.PositiveInfinity pozitív értékek esetén.

Ezen kívül Double.NaN, Double.PositiveInfinity és Double.NegativeInfinity egy OverflowException-t dob az egész számokká történő konvertáláskor egy ellenőrzött környezetben, de ezek az értékek túlcsordulnak, amikor nem ellenőrzött környezetben alakulnak egész számokká. A Decimal konvertálásánál mindig dob egy OverflowException. A konvertálás során Single-ra, Single.NaN-re, Single.PositiveInfinity-re és Single.NegativeInfinity-ra konvertálnak.

A pontosság elvesztését okozhatja, ha egy Double értéket más numerikus típussá alakít át. Az integráltípusok bármelyikére való konvertálás esetén, amint az a példa kimenetében látható, a tört összetevő elveszik, ha az Double érték kerekítve van (Visual Basic esetén) vagy csonkolva (a C# esetén). Konvertálások esetén Decimal és Single értékekre, előfordulhat, hogy az Double érték nem rendelkezik pontos ábrázolással a céladattípusban.

Az alábbi példa számos Double értéket konvertál több más numerikus típussá. A konvertálások egy ellenőrzött környezetben történnek Visual Basic (alapértelmezett), c# (a bejelölt kulcsszó miatt) és F# (a Checked modul miatt). A példában szereplő kimenet az eredményt mutatja mind az ellenőrzött, mind a nem ellenőrzött környezetben történő átalakításokra. A konvertálásokat a Visual Basicben ellenőrizetlen környezetben végezheti el a /removeintchecks+ fordítókapcsolóval való összeállítással, c# nyelven az checked utasítás megjegyzésével, F#-ban pedig az open Checked utasítás megjegyzésével.

using System;

public class Example5
{
    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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Int64.");
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to UInt64.");
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Decimal.");
                }
                try
                {
                    Single sValue = (float)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Single.");
                }
                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)

open System
open Checked

let values = 
    [| Double.MinValue; -67890.1234; -12345.6789
       12345.6789; 67890.1234; Double.MaxValue
       Double.NaN; Double.PositiveInfinity;
       Double.NegativeInfinity |]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."
    try
        let sValue = float32 value
        printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Single."
    printfn ""
// 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 Example6
    Public Sub Run()
        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)

A numerikus típusok konvertálásával kapcsolatos további információkért lásd a típuskonvertálást a .NET-ben és atípuskonvertálási táblákat.

Lebegőpontos funkciók

A Double struktúra és a kapcsolódó típusok a következő területeken biztosítják a műveletek végrehajtásának módszereit:

• Értékek összehasonlítása. Meghívhatja a Equals metódust annak meghatározására, hogy két Double érték egyenlő-e, vagy a CompareTo két érték közötti kapcsolatot meghatározó metódust.

  A Double struktúra az összehasonlító operátorok teljes készletét is támogatja. Tesztelheti például az egyenlőséget vagy az egyenlőtlenséget, vagy meghatározhatja, hogy az egyik érték nagyobb-e, mint egy másik. Ha az operandusok egyike nem egy numerikus típus Double, akkor az összehasonlítás végrehajtása előtt a program átalakítja azt egy Double számmá.

  Warning

  A pontosságbeli különbségek miatt két Double érték, amelyeket egyenlőnek várnak, eltérőnek bizonyulhatnak, ami befolyásolja az összehasonlítás eredményét. A két Double érték összehasonlításával kapcsolatos információkért lásd az Egyenlőségi teszt szakaszt.

  Meghívhatja a IsNaN, , IsInfinityIsPositiveInfinityés IsNegativeInfinity metódusokat is, hogy teszteljék ezeket a speciális értékeket.

• Matematikai műveletek. A gyakori aritmetikai műveleteket, például az összeadást, kivonást, szorzást és osztást nem metódusokkal hajtják végre, hanem a nyelvi fordítók és a közös köztes nyelv (CIL) utasításai. Ha egy matematikai művelet egyik operandusa nem egy numerikus típus Double, akkor a művelet végrehajtása előtt a program átalakítja egy operandussá Double . A művelet eredménye is egy Double érték.

  Más matematikai műveletek is elvégezhetők a static (Shared Visual Basic) metódus meghívásával a System.Math osztályban. Ez magában foglalja az aritmetikai (például Math.Abs, Math.Signés ), geometria (például Math.Sqrt és Math.CosMath.Sin) és számításhoz (például Math.Log) gyakran használt további módszereket is.

  Egy Double értékben az egyes biteket is manipulálhatja. A BitConverter.DoubleToInt64Bits metódus megőrzi egy Double érték bitmintáját egy 64 bites egész számban. A BitConverter.GetBytes(Double) metódus visszaadja a bitmintáját egy bájttömbben.

• Kerekítés. A kerekítést gyakran használják a lebegőpontos ábrázolás és pontosság problémái által okozott értékek közötti különbségek hatásának csökkentésére. A Double értéket a Math.Round függvény meghívásával kerekítheti.

• Formázás. Az Double értékeket sztringként is megjelenítheti a ToString metódus meghívásával vagy az összetett formázási funkció használatával. Az információért arról, hogyan szabályozzák a formátum stringek a lebegőpontos értékek sztring reprezentációját, lásd: Standard Numeric Format Strings és Custom Numeric Format Strings.

• Sztringek elemzése. A lebegőpontos érték sztringképét átalakíthatja Double értékké a Parse vagy a TryParse metódus meghívásával. Ha az elemzési művelet sikertelen, a Parse metódus kivételt ad vissza, míg a TryParse metódus ad vissza false.

• Típuskonvertálás. A Double struktúra explicit felületi implementációt biztosít a IConvertible interfészhez, amely támogatja a két szabványos .NET adattípus közötti átalakítást. A fordítók támogatják a standard numerikus típusok minden más értékének implicit átalakítását Double értékekké. Bármely standard numerikus típus Double értékének konvertálása kibővítő átalakítás, és nem igényel öntvény operátort vagy átalakítási módszert.

  Az értékek konvertálása Int64Single azonban a pontosság elvesztésével járhat. Az alábbi táblázat az alábbi típusok pontossági különbségeit sorolja fel:

  Típus	Maximális pontosság	Belső pontosság
  Double	15	17
  Int64	19 tizedesjegy	19 tizedesjegy
  Single	7 tizedesjegyek	9 tizedesjegy

  A pontosság problémája leggyakrabban az Single értékekből Double értékekké konvertált értékeket érinti. Az alábbi példában két azonos osztási művelet eredménye egyenlőtlen, mert az egyik egy egyszeres pontosságú lebegőpontos érték, amely átalakításra került egy Double típusú értékké.

  using System;
  
  public class Example13
  {
      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:           {result1:R}");
          Console.WriteLine($".1 Added 10 times: {result2:R}");
      }
  }
  // The example displays the following output:
  //       .1 * 10:           1
  //       .1 Added 10 times: 0.99999999999999989
  

  let value = 0.1
  let result1 = value * 10.
  let mutable result2 = 0.
  for i = 1 to 10 do
      result2 <- result2 + value
  
  printfn $".1 * 10:           {result1:R}"
  printfn $".1 Added 10 times: {result2:R}"
  // The example displays the following output:
  //       .1 * 10:           1
  //       .1 Added 10 times: 0.99999999999999989
  

  Module Example14
      Public Sub Run()
          Dim value As Double = 0.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
  

Mezők

Név	Description
E	Az állandó által megadott természetes logaritmikus bázist jelöli, e.
Epsilon	A legkisebb pozitív Double értéket jelöli, amely nagyobb, mint nulla. Ez a mező állandó.
MaxValue	A lehetséges legnagyobb értéket Doublejelöli. Ez a mező állandó.
MinValue	A lehető legkisebb értéket jelöli.Double Ez a mező állandó.
NaN	Olyan értéket jelöl, amely nem szám (NaN). Ez a mező állandó.
NegativeInfinity	Negatív végtelent jelöl. Ez a mező állandó.
NegativeZero	A negatív nullát (-0) jelöli.
Pi	Egy kör kerületének és átmérőjének a konstans által megadott π arányát jelöli.
PositiveInfinity	Pozitív végtelenséget jelöl. Ez a mező állandó.
Tau	A radiánok számát jelöli egyfordulóban, a τ állandó határozza meg.

Metódusok

Név	Description
Abs(Double)	Kiszámítja egy érték abszolút értékét.
Acos(Double)	Kiszámítja egy érték arc-koszinuszát.
Acosh(Double)	Kiszámítja egy érték hiperbolikus arc-koszinuszát.
AcosPi(Double)	Kiszámítja egy érték arc-koszinuszát, és elosztja az eredményt a következővel pi: .
Asin(Double)	Kiszámítja egy érték arc-szinuszát.
Asinh(Double)	Kiszámítja egy érték hiperbolikus arc-szinuszát.
AsinPi(Double)	Kiszámítja egy érték arc-szinuszát, és elosztja az eredményt a következővel pi: .
Atan(Double)	Kiszámítja egy érték ív-tangensét.
Atan2(Double, Double)	Két érték hányadosának ív-tangensét számítja ki.
Atan2Pi(Double, Double)	Kiszámítja a két érték hányadosának ív-tangensét, és az eredményt osztja el a következővel pi: .
Atanh(Double)	Kiszámítja egy érték hiperbolikus ív-tangensét.
AtanPi(Double)	Kiszámítja egy érték ív-tangensét, és pi-vel osztja el az eredményt.
BitDecrement(Double)	A megadott értéknél kisebb értéket összehasonlító legnagyobb értéket adja eredményül.
BitIncrement(Double)	A megadott értéknél nagyobbat hasonlító legkisebb értéket adja eredményül.
Cbrt(Double)	Kiszámítja egy érték kockagyökerét.
Ceiling(Double)	Kiszámítja egy érték felső határát.
Clamp(Double, Double, Double)	Egy értéket egy befogadó minimális és maximális értékhez rögzít.
ClampNative(Double, Double, Double)	Egy értéket egy befogadó minimális és maximális értékhez rögzít platformspecifikus viselkedéssel NaN és NegativeZero.
CompareTo(Double)	Összehasonlítja ezt a példányt egy megadott dupla pontosságú lebegőpontos számmal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott dupla pontosságú lebegőpontos szám értéke.
CompareTo(Object)	Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.
ConvertToInteger<TInteger>(Double)	Érték konvertálása megadott egész számtípusra túlcsordulási telítettség használatával
ConvertToIntegerNative<TInteger>(Double)	Egy értéket egy megadott egész számtípussá alakít át a túlcsordulás platformspecifikus viselkedésének használatával.
CopySign(Double, Double)	Egy érték jelét egy másik érték jelére másolja.
Cos(Double)	Kiszámítja egy érték koszinuszát.
Cosh(Double)	Kiszámítja egy érték koszinusz hiperbolikuszát.
CosPi(Double)	Kiszámítja a szorzott érték pikoszinuszát.
CreateChecked<TOther>(TOther)	Létrehozza az aktuális típus egy példányát egy értékből, amely túlcsordulási kivételt eredményez az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
CreateSaturating<TOther>(TOther)	Egy értékből hozza létre az aktuális típus egy példányát, amely az aktuális típus reprezentáló tartományán kívül eső értékeket telít át.
CreateTruncating<TOther>(TOther)	Az aktuális típus egy példányát hozza létre egy értékből, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
DegreesToRadians(Double)	Egy adott értéket radiánmá alakít át fokról radiánra.
Equals(Double)	Egy értéket ad vissza, amely jelzi, hogy ez a példány és egy adott Double objektum ugyanazt az értéket képviseli-e.
Equals(Object)	Egy értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal.
Exp(Double)	E Adott teljesítményre emelt számítások.
Exp10(Double)	10 Adott teljesítményre emelt számítások.
Exp10M1(Double)	10 Egy adott teljesítményre emelt számítások és kivonások.
Exp2(Double)	2 Adott teljesítményre emelt számítások.
Exp2M1(Double)	2 Egy adott teljesítményre emelt számítások és kivonások.
ExpM1(Double)	E Egy adott teljesítményre emelt számítások és kivonások.
Floor(Double)	Kiszámítja egy érték padlóját.
FusedMultiplyAdd(Double, Double, Double)	Kiszámítja a három érték összeolvadt szorzását.
GetHashCode()	A példány kivonatkódját adja vissza.
GetTypeCode()	TypeCode Az értéktípus Doubleértékét adja vissza.
Hypot(Double, Double)	Kiszámítja a hipotenuzát két érték alapján, amelyek egy derékszögű háromszög rövidebb oldalainak hosszát jelölik.
Ieee754Remainder(Double, Double)	Az IEEE 754 által megadott két érték fennmaradó részét számítja ki.
ILogB(Double)	Kiszámítja egy érték egész logaritmusát.
IsEvenInteger(Double)	Meghatározza, hogy egy érték páros integrál számot jelöl-e.
IsFinite(Double)	Meghatározza, hogy a megadott érték véges-e (nulla, szubnormális vagy normál).
IsInfinity(Double)	Egy értéket ad vissza, amely azt jelzi, hogy a megadott szám negatív vagy pozitív végtelen lesz-e.
IsInteger(Double)	Meghatározza, hogy egy érték egy integrál értéket jelöl-e.
IsNaN(Double)	Olyan értéket ad vissza, amely azt jelzi, hogy a megadott érték nem szám-e (NaN).
IsNegative(Double)	Meghatározza, hogy a megadott érték negatív-e.
IsNegativeInfinity(Double)	Egy értéket ad vissza, amely azt jelzi, hogy a megadott szám negatív végtelen lesz-e.
IsNormal(Double)	Meghatározza, hogy a megadott érték normális-e.
IsOddInteger(Double)	Meghatározza, hogy egy érték páratlan integrál számot jelöl-e.
IsPositive(Double)	Meghatározza, hogy egy érték pozitív-e.
IsPositiveInfinity(Double)	Egy értéket ad vissza, amely azt jelzi, hogy a megadott szám pozitív végtelen lesz-e.
IsPow2(Double)	Meghatározza, hogy egy érték kettőből áll-e.
IsRealNumber(Double)	Meghatározza, hogy egy érték valós számot jelöl-e.
IsSubnormal(Double)	Meghatározza, hogy a megadott érték szubnormális-e.
Lerp(Double, Double, Double)	Lineáris interpolációt végez két érték között a megadott súly alapján.
Log(Double, Double)	Kiszámítja egy érték logaritmusát a megadott alapban.
Log(Double)	Kiszámítja egy érték természetes (base-E logaritmusát).
Log10(Double)	Kiszámítja egy érték 10-es alapú logaritmusát.
Log10P1(Double)	Kiszámítja egy érték és egy érték 10-es logaritmusát.
Log2(Double)	Kiszámítja egy érték napló2-ét.
Log2P1(Double)	Egy érték és egy érték 2-es logaritmusát számítja ki.
LogP1(Double)	Kiszámítja egy érték természetes (base-E) logaritmusát plusz egy értékkel.
Max(Double, Double)	Két értéket hasonlít össze a nagyobb számítási értékekkel.
MaxMagnitude(Double, Double)	Két értéket hasonlít össze a nagyobb számítási értékekkel.
MaxMagnitudeNumber(Double, Double)	Két értéket hasonlít össze a számítással, amelynek nagyobb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
MaxNative(Double, Double)	Két értéket hasonlít össze a számítással, amely nagyobb a platformspecifikus viselkedés és NaNa NegativeZero .
MaxNumber(Double, Double)	Két értéket hasonlít össze a számítással, amely nagyobb, és a másik értéket adja vissza, ha egy bemenet .NaN
Min(Double, Double)	Két értéket hasonlít össze a kisebb számítási értékkel.
MinMagnitude(Double, Double)	Két értéket hasonlít össze a kisebb számítási értékkel.
MinMagnitudeNumber(Double, Double)	Két értéket hasonlít össze a számítással, amelynek kisebb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
MinNative(Double, Double)	Két értéket hasonlít össze a számítással, amely kisebb a platformspecifikus viselkedés és NaNa NegativeZero .
MinNumber(Double, Double)	Két értéket hasonlít össze a kisebb számítási értékkel, és a másik értéket adja vissza, ha egy bemenet .NaN
MultiplyAddEstimate(Double, Double, Double)	Kiszámítja a (left * right) + addendbecslést.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 karakterből álló tartományt elemez egy értékben.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 karakterből álló tartományt elemez egy értékben.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Egy adott stílusban és kultúrában megadott formátumban lévő szám sztring-ábrázolását tartalmazó karakterfedezetet alakít át dupla pontosságú lebegőpontos számegyenértékké.
Parse(String, IFormatProvider)	Egy adott kultúraspecifikus formátumban lévő szám sztringképét dupla pontosságú lebegőpontos számegyenértékké alakítja.
Parse(String, NumberStyles, IFormatProvider)	Egy szám sztring-ábrázolását egy megadott stílusban és kultúraspecifikus formátumban alakítja át dupla pontosságú lebegőpontos számegyenértékké.
Parse(String, NumberStyles)	Egy adott stílusban lévő szám sztringképét dupla pontosságú lebegőpontos számegyenértékké alakítja.
Parse(String)	Egy szám sztringképét dupla pontosságú lebegőpontos számegyenértékké alakítja.
Pow(Double, Double)	Kiszámít egy adott teljesítményre emelt értéket.
RadiansToDegrees(Double)	Egy adott értéket radiánból fokmá alakít át.
ReciprocalEstimate(Double)	Kiszámítja egy érték reciprokának becslését.
ReciprocalSqrtEstimate(Double)	Kiszámítja egy érték reciprok négyzetgyökének becslését.
RootN(Double, Int32)	Kiszámítja egy érték n-edik gyökerét.
Round(Double, Int32, MidpointRounding)	Egy értéket az alapértelmezett kerekítési mód (ToEven) használatával adott számú törtjegyre kerekített.
Round(Double, Int32)	Egy értéket az alapértelmezett kerekítési mód (ToEven) használatával adott számú törtjegyre kerekített.
Round(Double, MidpointRounding)	Egy értéket a megadott kerekítési móddal a legközelebbi egész számra kerekít.
Round(Double)	Egy értéket az alapértelmezett kerekítési mód (ToEven) használatával a legközelebbi egész számra kerekít.
ScaleB(Double, Int32)	Kiszámítja egy érték szorzatát és a megadott teljesítményre emelt alap radixát.
Sign(Double)	Kiszámítja egy érték jelét.
Sin(Double)	Kiszámítja egy érték szinuszát.
SinCos(Double)	Kiszámítja egy érték szinuszát és koszinuszát.
SinCosPi(Double)	Kiszámítja egy érték szinuszát és koszinuszát.
Sinh(Double)	Kiszámítja egy érték szinusz hiperbolikuszát.
SinPi(Double)	A szorzott érték szinuszát számítja ki pi.
Sqrt(Double)	Kiszámítja egy érték négyzetgyökét.
Tan(Double)	Kiszámítja egy érték tangensét.
Tanh(Double)	Kiszámítja egy érték hiperbolikus tangensét.
TanPi(Double)	Kiszámítja a szorzott érték tangensét pi.
ToString()	A példány numerikus értékét a megfelelő sztring-ábrázolásúvá alakítja.
ToString(IFormatProvider)	A példány numerikus értékét a megadott kultúraspecifikus formátumadatok használatával konvertálja a megfelelő sztringre.
ToString(String, IFormatProvider)	Ennek a példánynak a numerikus értékét a megadott formátum- és kultúraspecifikus formátuminformációk használatával konvertálja a megfelelő sztringre.
ToString(String)	A megadott formátum használatával a példány numerikus értékét a megfelelő sztring-ábrázolásúvá alakítja.
Truncate(Double)	Csonkít egy értéket.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Az aktuális példány értékét UTF-8 formátumban próbálja formázni a megadott bájttartományba.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Megpróbálja formázni az aktuális dupla példány értékét a megadott karaktertartományba.
TryParse(ReadOnlySpan<Byte>, Double)	Egy szám sztringképét tartalmazó UTF-8 karaktert próbál átalakítani a kettős pontosságú lebegőpontos számmal egyenértékűre.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	Egy UTF-8 karakterből álló pántot próbál elemezni egy értékben.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	Egy UTF-8 karakterből álló pántot próbál elemezni egy értékben.
TryParse(ReadOnlySpan<Char>, Double)	Egy adott stílusban és kultúrában megadott formátumban lévő szám span-ábrázolását dupla pontosságú lebegőpontos számegyenértékké alakítja. A visszatérési érték azt jelzi, hogy az átalakítás sikeres vagy sikertelen volt-e.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Egy karaktertartományt próbál elemezni egy értékben.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Egy adott stílusban és kultúrában megadott formátumú szám sztring-ábrázolását tartalmazó karakterfedést alakít át dupla pontosságú lebegőpontos számegyenértékké. A visszatérési érték azt jelzi, hogy az átalakítás sikeres vagy sikertelen volt-e.
TryParse(String, Double)	Egy szám sztringképét dupla pontosságú lebegőpontos számegyenértékké alakítja. A visszatérési érték azt jelzi, hogy az átalakítás sikeres vagy sikertelen volt-e.
TryParse(String, IFormatProvider, Double)	Megpróbál egy sztringet egy értékbe elemezni.
TryParse(String, NumberStyles, IFormatProvider, Double)	Egy szám sztring-ábrázolását egy megadott stílusban és kultúraspecifikus formátumban alakítja át dupla pontosságú lebegőpontos számegyenértékké. A visszatérési érték azt jelzi, hogy az átalakítás sikeres vagy sikertelen volt-e.

Operátorok

Név	Description
Equality(Double, Double)	Olyan értéket ad vissza, amely jelzi, hogy két megadott Double érték egyenlő-e.
GreaterThan(Double, Double)	Olyan értéket ad vissza, amely azt jelzi, hogy egy megadott Double érték nagyobb-e egy másik megadott Double értéknél.
GreaterThanOrEqual(Double, Double)	Olyan értéket ad vissza, amely azt jelzi, hogy egy megadott Double érték nagyobb-e, mint egy másik megadott Double érték.
Inequality(Double, Double)	Olyan értéket ad vissza, amely jelzi, hogy két megadott Double érték nem egyenlő-e.
LessThan(Double, Double)	Olyan értéket ad vissza, amely azt jelzi, hogy egy megadott Double érték kisebb-e egy másik megadott Double értéknél.
LessThanOrEqual(Double, Double)	Olyan értéket ad vissza, amely azt jelzi, hogy egy megadott Double érték kisebb-e, mint egy másik megadott Double érték.

Explicit interfész-implementációk

Név	Description
IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	Két értéket ad hozzá az összeg kiszámításához.
IAdditiveIdentity<Double,Double>.AdditiveIdentity	Lekéri az aktuális típus additív identitását.
IBinaryNumber<Double>.AllBitsSet	Lekéri annak a bináris típusnak a példányát, amelyben az összes bit be van állítva.
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	Kiszámítja a bitenkénti és két értéket.
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	Kiszámítja a bitenkénti vagy két értéket.
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	Kiszámítja a kizárólagos vagy két értéket.
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	Kiszámítja egy adott érték egyedkiegészítő ábrázolását.
IConvertible.ToBoolean(IFormatProvider)	Ennek a tagnak a leírását lásd ToBoolean(IFormatProvider): .
IConvertible.ToByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToByte(IFormatProvider): .
IConvertible.ToChar(IFormatProvider)	Ez az átalakítás nem támogatott. A metódus használatának megkísérlése egy InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Ez az átalakítás nem támogatott. A metódus használatának megkísérlése egy InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Ennek a tagnak a leírását lásd ToDecimal(IFormatProvider): .
IConvertible.ToDouble(IFormatProvider)	Ennek a tagnak a leírását lásd ToDouble(IFormatProvider): .
IConvertible.ToInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt16(IFormatProvider): .
IConvertible.ToInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt32(IFormatProvider): .
IConvertible.ToInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt64(IFormatProvider): .
IConvertible.ToSByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToSByte(IFormatProvider): .
IConvertible.ToSingle(IFormatProvider)	Ennek a tagnak a leírását lásd ToSingle(IFormatProvider): .
IConvertible.ToType(Type, IFormatProvider)	Ennek a tagnak a leírását lásd ToType(Type, IFormatProvider): .
IConvertible.ToUInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt16(IFormatProvider): .
IConvertible.ToUInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt32(IFormatProvider): .
IConvertible.ToUInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt64(IFormatProvider): .
IDecrementOperators<Double>.Decrement(Double)	Érték decresítése.
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	Az egyik értéket egy másikkal osztja el a hányados kiszámításához.
IFloatingPoint<Double>.GetExponentByteCount()	Beolvasja a program által a program részeként megírt bájtok TryWriteExponentLittleEndian(Span<Byte>, Int32)számát.
IFloatingPoint<Double>.GetExponentShortestBitLength()	Bitekben lekéri az aktuális kitevő rövidítésének hosszát.
IFloatingPoint<Double>.GetSignificandBitLength()	Lekéri az aktuális jelző hosszát bitben.
IFloatingPoint<Double>.GetSignificandByteCount()	Beolvasja a program által a program részeként megírt bájtok TryWriteSignificandLittleEndian(Span<Byte>, Int32)számát.
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Megpróbálja megírni az aktuális kitevőt big endian formátumban egy adott időtartamra.
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Megpróbálja megírni az aktuális kitevőt, kis végű formátumban, egy adott időtartamra.
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Megpróbálja megírni az aktuális jelzőt, és big-endian formátumban egy adott időtartamra.
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Megpróbálja megírni az aktuális jelzőt, és kis endian formátumban egy adott tartományba.
IFloatingPointConstants<Double>.E	Lekéri a matematikai állandót e.
IFloatingPointConstants<Double>.Pi	Lekéri a matematikai állandót pi.
IFloatingPointConstants<Double>.Tau	Lekéri a matematikai állandót tau.
IFloatingPointIeee754<Double>.Epsilon	Lekéri a legkisebb értéket, amely hozzáadható 0 az eredményhez 0.
IFloatingPointIeee754<Double>.NaN	A értéket adja NaNmeg.
IFloatingPointIeee754<Double>.NegativeInfinity	Negatív infinityértéket kap.
IFloatingPointIeee754<Double>.NegativeZero	Negatív zeroértéket kap.
IFloatingPointIeee754<Double>.PositiveInfinity	Pozitív értéket kap infinity.
IIncrementOperators<Double>.Increment(Double)	Növekményes érték.
IMinMaxValue<Double>.MaxValue	Az aktuális típus maximális értékét adja meg.
IMinMaxValue<Double>.MinValue	Az aktuális típus minimális értékét adja meg.
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	Két értéket oszt össze a modulus vagy a maradék kiszámításához.
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	Lekéri az aktuális típus többszörös identitását.
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	Két értéket szoroz össze a termék kiszámításához.
INumberBase<Double>.IsCanonical(Double)	Meghatározza, hogy egy érték a vesszővel ábrázolt érték-e.
INumberBase<Double>.IsComplexNumber(Double)	Meghatározza, hogy egy érték összetett számot jelöl-e.
INumberBase<Double>.IsImaginaryNumber(Double)	Meghatározza, hogy egy érték tiszta képzeletbeli számot jelöl-e.
INumberBase<Double>.IsZero(Double)	Meghatározza, hogy egy érték nulla-e.
INumberBase<Double>.One	Lekéri a típus értékét 1 .
INumberBase<Double>.Radix	Lekéri a típus radixát vagy bázist.
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	Dupla pontosságú lebegőpontos számot jelöl.
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	Dupla pontosságú lebegőpontos számot jelöl.
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	Dupla pontosságú lebegőpontos számot jelöl.
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és túlcsordulási kivételt okoz az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és az aktuális típus reprezentáló tartományán kívül eső értékeket telít.
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
INumberBase<Double>.Zero	Lekéri a típus értékét 0 .
ISignedNumber<Double>.NegativeOne	Lekéri a típus értékét -1 .
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	Kivon két értéket a különbség kiszámításához.
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	Kiszámítja egy érték nem kötelező negációját.
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	Kiszámítja egy érték unáris pluszát.

Szálbiztonság

Az ilyen típusú tagok szálbiztosak. Azok a tagok, amelyek úgy tűnik, hogy módosítják a példány állapotát, valójában egy új példányt ad vissza, amely inicializálva van az új értékkel. Mint minden más típus esetén, az ilyen típusú példányt tartalmazó megosztott változókra való olvasást és írást zárolással kell védeni a szálbiztonság érdekében.

Lásd még

• Decimal
• Single
• minta: .NET Core WinForms Formatting Utility (C#)
• minta: .NET Core WinForms Formatting Utility (Visual Basic)