Double Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Double.cs

Çift duyarlıklı kayan nokta sayısını temsil eder.

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)

Devralma

Object

ValueType

Double

Uygulamalar

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>

Örnekler

Aşağıdaki kod örneğinde Doublekullanımı gösterilmektedir:

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

Açıklamalar

Double değer türü, negatif 1,79769313486232e308 ile pozitif 1,79769313486232e308 arasında değişen değerlerin yanı sıra pozitif veya negatif sıfır, PositiveInfinity, NegativeInfinity ve sayı değil (NaN) ile çift hassasiyetli bir 64 bit sayıyı temsil eder. Son derece büyük (gezegenler veya galaksiler arasındaki uzaklıklar gibi) veya son derece küçük (kilogram cinsinden bir maddenin moleküler kütlesi gibi) ve genellikle belirsiz olan değerleri (örneğin, dünyadan başka bir güneş sistemine olan uzaklığı) temsil etmeye yöneliktir. Double türü, ikili kayan nokta aritmetiği için IEC 60559:1989 (IEEE 754) standardına uygundur.

Kayan nokta gösterimi ve hassasiyet

Double veri türü, aşağıdaki tabloda gösterildiği gibi çift duyarlıklı kayan nokta değerlerini 64 bit ikili biçimde depolar:

Bölüm	Bitler
İşaret veya mantis	0-51
Exponent	52-62
İşaret (0 = Pozitif, 1 = Negatif)	63

Ondalık kesirlerin bazı kesirli değerleri (1/3 veya Math.PIgibi) tam olarak temsil edemediği gibi, ikili kesirler de bazı kesirli değerleri temsil edemez. Örneğin, ondalık kesir olarak tam olarak .1 ile temsil edilen 1/10, .001100110011 ile ikili kesir olarak temsil edilir ve "0011" deseni sonsuza kadar yineleniyor. Bu durumda kayan nokta değeri, temsil ettiği sayının kesin olmayan bir gösterimini sağlar. Özgün kayan nokta değeri üzerinde ek matematiksel işlemler gerçekleştirmek genellikle duyarlık eksikliğini artırma eğilimindedir. Örneğin, .1 değerini 10 ile çarpıp .1 değerini dokuz kez ekleyerek elde ettiğiniz sonucu karşılaştırırsanız, sekiz işlem daha içerdiğinden bu toplamanın daha az kesin sonuç ürettiğini görürsünüz. .NET 10'dan önce, bu fark yalnızca "R" Double kullanılarak iki değeri görüntülediğinizde görünür ve bu, Double türü tarafından desteklenen en fazla 17 duyarlık basamağını görüntüler.

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

Bazı sayılar tam olarak kesirli ikili değerler olarak temsil edilemediği için kayan noktalı sayılar yalnızca gerçek sayılara yakın olabilir.

Tüm kayan noktalı sayılar da sınırlı sayıda anlamlı basamağı vardır ve bu da kayan nokta değerinin gerçek bir sayıya ne kadar doğru yakın olduğunu belirler. Bir Double değeri, dahili olarak en fazla 17 basamak korunmasına rağmen en fazla 15 ondalık basamak hassasiyeti sağlar. Bu, bazı kayan nokta işlemlerinin kayan nokta değerini değiştirme duyarlığından yoksun olabileceği anlamına gelir. Aşağıdaki örnek, bir gösterim sağlar. Çok büyük bir kayan nokta değeri tanımlar ve ardından bu değere Double.Epsilon ile bir katrilyonun çarpımını ekler. Ancak ürün, özgün kayan nokta değerini değiştiremeyecek kadar küçük. En az önemli basama binde bir, üründeki en önemli basamak ise 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

Kayan noktalı bir sayının sınırlı duyarlığı çeşitli sonuçlara neden olur:

• Belirli bir duyarlık için eşit görünen iki kayan noktalı sayı eşit olmayabilir, çünkü en az önemli basamakları farklıdır. Aşağıdaki örnekte, bir dizi sayı bir araya eklenir ve bunların toplamı beklenen toplamlarıyla karşılaştırılır.

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

  Toplama işlemleri sırasında kesinlik kaybı nedeniyle iki değer eşit değildir. Bu durumda sorun, karşılaştırmayı gerçekleştirmeden önce Math.Round(Double, Int32) değerlerini istenen duyarlıkta yuvarlamak için Double yöntemi çağrılarak çözülebilir.

• Kayan noktalı sayı kullanan bir matematik veya karşılaştırma işlemi, ondalık sayı kullanıldığında aynı sonucu vermeyebilir çünkü ikili kayan noktalı sayı ondalık sayıya eşit olmayabilir. Önceki bir örnek, .1 ile 10 çarpımının sonucunu görüntüleyip 0,1 kez ekleyerek bunu göstermiş.

  Kesirli değerler içeren sayısal işlemlerde doğruluk önemliyse, Decimal türü yerine Double türünü kullanabilirsiniz. Int128 UInt128 türlerinin aralığını aşan tamsayı değerlerine sahip sayısal işlemlerde doğruluk önemliyse, BigInteger türünü kullanın.

• Single değerlerin duyarlığı Double değerlerden daha azdır. Single değeri, eşdeğer gibi görünen bir Double değerine dönüştürüldüğünde, genellikle Double değerle eşit olmaz, çünkü duyarlık farklılıkları vardır. Aşağıdaki örnekte, aynı bölme işlemlerinin sonucu bir Double ve Single değerine atanır. Single değeri bir Double'a atandıktan sonra, iki değerin karşılaştırması bunların eşit olmadığını gösterir.

  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
  

  Bu sorunu önlemek için, Double veri türünün yerine Single kullanın veya her iki değerin de aynı duyarlıkta sahip olması için Round yöntemini kullanın.

Buna ek olarak, Double değerleriyle yapılan aritmetik ve atama işlemlerinin sonucu, Double türünün duyarlık kaybı nedeniyle platforma göre biraz farklılık gösterebilir. Örneğin, değişmez bir Double değeri atamanın sonucu, .NET'in 32 bit ve 64 bit sürümlerinde farklılık gösterebilir. Aşağıdaki örnek, -4,42330604244772E-305 sabit değeri ve değeri -4,42330604244772E-305 olan bir değişkenin Double değişkenine atandığında ortaya çıkan farkı göstermektedir. Bu durumda Parse(String) yönteminin sonucunun duyarlık kaybı yaşamadığını unutmayın.

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

Eşitlik testi

Eşit kabul edilmesi için iki Double değerin aynı değerleri temsil etmesi gerekir. Ancak, değerler arasındaki duyarlık farklılıkları nedeniyle veya bir veya her iki değere göre duyarlık kaybı nedeniyle, özdeş olması beklenen kayan nokta değerleri genellikle en az önemli basamaklarındaki farklılıklar nedeniyle eşit değildir. Sonuç olarak, iki değerin eşit olup olmadığını belirlemek için Equals yöntemine çağrılar veya iki CompareTo değer arasındaki ilişkiyi belirlemek için Double yöntemine çağrılar, genellikle beklenmeyen sonuçlar verir. Bu, aşağıdaki örnekte açıktır; iki görünüşte eşit Double değeri, birinci değerin 15 basamak duyarlığı, ikincinin ise 17 basamağa sahip olması nedeniyle eşit olmaz.

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

Bir duyarlık kaybının karşılaştırmanın sonucunu etkileyeceği durumlarda, Equals veya CompareTo yöntemini çağırmak için aşağıdaki alternatiflerden herhangi birini benimseyebilirsiniz:

• her iki değerin de aynı duyarlıkta sahip olduğundan emin olmak için Math.Round yöntemini çağırın. Aşağıdaki örnek, önceki bir örneği bu yaklaşımı kullanacak şekilde değiştirerek iki kesirli değerin eşdeğer olmasını sağlar.

  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
  

  Kesinlik sorunu orta nokta değerlerini yuvarlama için de geçerlidir. Daha fazla bilgi için bkz. Math.Round(Double, Int32, MidpointRounding) yöntemi.

• Eşitlik yerine yaklaşık eşitlik testi. Bu, iki değerin farklı ancak yine de eşit olabileceği mutlak bir tutar tanımlamanızı veya daha küçük değerin daha büyük değerden ayrışabileceği göreli bir miktar tanımlamanızı gerektirir.

  Warning

  Double.Epsilon bazen eşitlik testi sırasında iki Double değeri arasındaki uzaklığın mutlak bir ölçüsü olarak kullanılır. Ancak Double.Epsilon değeri sıfır olan bir Double eklenebilecek veya çıkarılabilen en küçük olası değeri ölçer. Çoğu pozitif ve negatif Double değeri için Double.Epsilon değeri algılanamaz kadar küçüktür. Bu nedenle, sıfır olan değerler dışında, eşitlik için testlerde kullanılmasını önermeyiz.

  Aşağıdaki örnek, iki değer arasındaki göreli farkı test eden bir IsApproximatelyEqual yöntemi tanımlamak için ikinci yaklaşımı kullanır. Yöntem, Math.Max(value1, value2) ile böler, böylece karşılaştırma, iki değerin büyüklük açısından daha büyük olanına göre yapılır ve sonuç doğru büyüklük sırasına yerleştirilir. Eğer Math.Max sıfır döndürürse (bir değer sıfır olduğunda ve diğeri negatif olduğunda meydana gelir), yöntem sıfır olmayan değeri bölen olarak kullanmak için Math.Min(value1, value2) yöntemine geri döner. Ayrıca IsApproximatelyEqual yöntemine ve Equals(Double) yöntemine yapılan çağrıların sonucunu karşılaştırır.

  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
  

Kayan nokta değerleri ve özel durumları

Tamsayı türleriyle yapılan işlemler, sıfıra bölme veya denetlenen bir bağlamda taşma durumlarında veya hatası oluştururken, kayan nokta değerleriyle yapılan işlemler böyle durumlarda özel durum oluşturmaz. Bunun yerine, olağanüstü durumlarda kayan nokta işleminin sonucu sıfır, pozitif sonsuz, negatif sonsuzdur veya sayı değildir (NaN):

• Kayan nokta işleminin sonucu hedef biçim için çok küçükse, sonuç sıfır olur. Aşağıdaki örnekte gösterildiği gibi, çok küçük iki sayı çarpıldığında bu durum oluşabilir.

  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
  

• Kayan nokta işleminin sonucunun büyüklüğü hedef biçimin aralığını aşarsa, sonucun işaretine uygun olarak işlemin sonucu PositiveInfinity veya NegativeInfinityolur. Double.MaxValue taşan bir işlemin sonucu PositiveInfinityve aşağıdaki örnekte gösterildiği gibi Double.MinValue taşan bir işlemin sonucu NegativeInfinity' dir.

  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, pozitif bir bölünenin sıfıra bölünmesi sonucu elde edilir ve NegativeInfinity, negatif bir bölünenin sıfıra bölünmesi sonucu elde edilir.

• Kayan nokta işlemi geçersizse, işlemin sonucu NaNolur. Örneğin, NaN aşağıdaki işlemlerden elde edilir:

  • Sıfıra, sıfırla bölme. Sıfıra bölmenin diğer durumlarının PositiveInfinity veya NegativeInfinityile sonuçlandığını unutmayın.

  • Geçersiz giriş içeren herhangi bir kayan nokta işlemi. Örneğin, Math.Sqrt yöntemini negatif bir değerle çağırmak, NaN yöntemini bir veya daha az negatif bir değerle çağırmak gibi Math.Acosdöndürür.

  • Değeri Double.NaNolan bağımsız değişkenle yapılan herhangi bir işlem.

Tip dönüştürmeleri

Double yapısı herhangi bir açık veya örtük dönüştürme işleci tanımlamaz; bunun yerine, dönüştürmeler derleyici tarafından uygulanır.

Herhangi bir ilkel sayısal türün değerinin Double'a dönüştürülmesi bu bir genişletme dönüştürmesidir, bu yüzden derleyici açıkça gerektirmediği sürece açık bir atama işleci veya dönüştürme yöntemi çağrısına gerek yoktur. Örneğin, C# derleyicisi Decimal'den Double'a dönüştürmeler için bir atama işleci gerektirir, ancak Visual Basic derleyicisi bunu yapmaz. Aşağıdaki örnek, diğer ilkel sayısal türlerin en düşük veya en yüksek değerini Doubledönüştürür.

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)

Ayrıca, Single değerleri sırasıyla Single.NaN, Single.PositiveInfinityve Single.NegativeInfinityDouble.NaN, Double.PositiveInfinityve Double.NegativeInfinitydönüştürülür.

Bazı sayısal türlerin değerinin Double bir değere dönüştürülmesinin doğruluk kaybına yol açabileceğini unutmayın. Örnekte gösterildiği gibi, Decimal, Int64ve UInt64 değerleri Double değerlere dönüştürülürken duyarlık kaybı mümkündür.

Double değerinin başka bir ilkel sayısal veri türünün değerine dönüştürülmesi bir daraltma dönüştürme işlemidir ve bir dönüştürme işleci (C#'de), dönüştürme yöntemi (Visual Basic) veya Convert yöntemine çağrı gerektirir. Hedef türün MinValue ve MaxValue özellikleri tarafından tanımlanan hedef veri türü aralığının dışında olan değerler, aşağıdaki tabloda gösterildiği gibi davranır.

Hedef türü	Result
Herhangi bir tam sayı türü	Dönüştürme denetlenen bir bağlamda gerçekleşirse bir OverflowException istisnası. Dönüştürme denetimsiz bir bağlamda gerçekleşirse (C# dilinde varsayılan), dönüştürme işlemi başarılı olur ancak değer taşması meydana gelir.
Decimal	Bir OverflowException istisnası.
Single	Negatif değerler için Single.NegativeInfinity. Pozitif değerler için Single.PositiveInfinity.

Buna ek olarak, Double.NaN, Double.PositiveInfinityve Double.NegativeInfinity, denetlenmiş bağlamda tamsayı dönüştürmeleri için bir OverflowException istisnası fırlatır, ancak bu değerler kontrolsüz bir bağlamda tamsayılara dönüştürüldüğünde taşma meydana gelir. Decimaldönüştürmeleri için her zaman bir OverflowExceptionfırlatırlar. "Single'a dönüştürmeler için, sırasıyla, Single.NaN, Single.PositiveInfinityve Single.NegativeInfinity'e dönüştürülür."

Duyarlık kaybı, bir değerin başka bir Double sayısal türe dönüştürülmesiyle sonuçlanabilir. Bütünleşik türlerden herhangi birine dönüştürme durumunda, örnek çıktısında gösterildiği gibi, Double değeri Visual Basic'te yuvarlandığında veya C# dilinde kırpıldığında kesirli bileşen kaybolur. Decimal ve Single değerlerine dönüştürmelerde, Double değerinin hedef veri türünde kesin bir gösterimi olmayabilir.

Aşağıdaki örnek, bir dizi Double değerini diğer birkaç sayısal türe dönüştürür. Dönüştürmeler, Visual Basic(varsayılan), C# dilinde (checked anahtar sözcüğü nedeniyle) ve F# dilinde (Checked modülü nedeniyle) denetlenen bir bağlamda gerçekleşir. Örnekten elde edilen çıktı, hem işaretli hem de işaretsiz bağlamlarda yapılan dönüştürmelerin sonucunu gösterir. Visual Basic'te /removeintchecks+ derleyici anahtarıyla derleyerek, C# dilinde checked ifadesini yorum satırına alarak ve F# dilinde open Checked ifadesini yorum satırına alarak denetlenmeyen bir bağlamda dönüşüm gerçekleştirebilirsiniz.

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)

Sayısal türlerin dönüştürülmesi hakkında daha fazla bilgi için .NET'te Tür Dönüştürme ve Tür Dönüştürme Tabloları bölümlerine bakın.

Kayan nokta işlevselliği

Double yapısı ve ilgili türler aşağıdaki alanlarda işlem gerçekleştirmek için yöntemler sağlar:

• değerleri karşılaştırması. İki Equals değerin eşit olup olmadığını belirlemek için Double yöntemini veya iki değer arasındaki ilişkiyi belirlemek için CompareTo yöntemini çağırabilirsiniz.

  Double yapısı tam bir karşılaştırma işleçleri kümesini de destekler. Örneğin, eşitliği veya eşitsizliği test edebilir veya bir değerin başka bir değerden büyük mü yoksa başka bir değere eşit mi olduğunu belirleyebilirsiniz. İşlenenlerden biri Double dışında bir sayısal türse, karşılaştırma gerçekleştirilmeden önce Double türüne dönüştürülür.

  Warning

  Duyarlık farklılıkları nedeniyle, eşit olmasını beklediğiniz iki Double değerin eşit olmadığı ortaya çıkabilir ve bu da karşılaştırmanın sonucunu etkiler. İki Double değeri karşılaştırma hakkında bilgi için Eşitlik testi bölümüne bakın.

  Ayrıca, bu özel değerleri test etmek için IsNaN, IsInfinity, IsPositiveInfinityve IsNegativeInfinity yöntemlerini çağırabilirsiniz.

• Matematiksel işlemler. Toplama, çıkarma, çarpma ve bölme gibi yaygın aritmetik işlemler, Double yöntemleri yerine dil derleyicileri ve Ortak Ara Dil (CIL) yönergeleri tarafından uygulanır. Matematiksel bir işlemdeki işlenenlerden biri Double dışındaki bir sayısal türse, bu işlemenden Double türüne dönüştürülür ve ardından işlem gerçekleştirilir. İşlemin sonucu da Double değeridir.

  Diğer matematik işlemleri, static sınıfında Shared (Visual Basic'da System.Math) yöntemleri çağrılarak gerçekleştirilebilir. Aritmetik (Math.Abs, Math.Signve Math.Sqrt), geometri (Math.Cos ve Math.Singibi) ve hesap (Math.Loggibi) için yaygın olarak kullanılan ek yöntemleri içerir.

  Ayrıca, Double bir değerdeki tek tek bitleri de işleyebilirsiniz. BitConverter.DoubleToInt64Bits yöntemi, Double değerin bit desenini 64 bitlik bir tamsayıda korur. BitConverter.GetBytes(Double) yöntemi bit desenini bayt dizisinde döndürür.

• Yuvarlama. Yuvarlama, genellikle, kayan nokta gösterimi ve kesinlik sorunlarının neden olduğu değerler arasındaki farkların etkisini azaltmak için bir teknik olarak kullanılır. Double yöntemini çağırarak Math.Round değeri yuvarlayabilirsiniz.

• Biçimlendirme. Double yöntemini çağırarak veya bileşik biçimlendirme özelliğini kullanarak bir ToString değerini dize gösterimine dönüştürebilirsiniz. Biçim dizelerinin kayan nokta değerlerinin dize gösterimini nasıl denetlediğini öğrenmek için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.

• Dizeleri ayrıştırma. Kayan nokta değerinin dize gösterimini, Double veya Parse yöntemini çağırarak TryParse bir değere dönüştürebilirsiniz. Ayrıştırma işlemi başarısız olursa, Parse yöntemi bir özel durum oluştururken, TryParse yöntemi falsedöndürür.

• Tür dönüştürme. Double yapısı, iki standart .NET veri türü arasında dönüştürmeyi destekleyen IConvertible arabirimi için açık bir arabirim uygulaması sağlar. Dil derleyicileri, diğer tüm standart sayısal türlerdeki değerlerin örtük olarak Double değerlere dönüştürülmesini de destekler. Herhangi bir standart sayısal türün değerinin Double'a dönüştürülmesi bir genişletme dönüştürmesidir ve bir atama işlecinin veya dönüştürme yönteminin kullanımını gerektirmez.

  Ancak, Int64 ve Single değerlerinin dönüştürülmesi duyarlık kaybı içerebilir. Aşağıdaki tabloda, bu türlerin her biri için duyarlık farklılıkları listelenmiştir:

  Türü	En yüksek duyarlık	İçsel doğruluk
  Double	15	17
  Int64	19 ondalık basamak	19 ondalık basamak
  Single	7 ondalık basamak	9 ondalık basamak

  Hassasiyet sorunu, en sık Single değerleri Double değerlere dönüştürüldüğünde etkiler. Aşağıdaki örnekte, aynı bölme işlemleri tarafından üretilen iki değer eşit değildir çünkü değerlerden biri, tek duyarlıklı kayan nokta değeri olup Double'e dönüştürülmüştür.

  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
  

Alanlar

Name	Description
E	e sabiti tarafından belirtilen doğal logaritmik tabanı temsil eder.
Epsilon	Sıfırdan büyük en küçük pozitif Double değeri temsil eder. Bu alan sabittir.
MaxValue	Bir öğesinin mümkün olan en büyük değerini Doubletemsil eder. Bu alan sabittir.
MinValue	Bir öğesinin mümkün olan en küçük değerini Doubletemsil eder. Bu alan sabittir.
NaN	SayıNaN () olmayan bir değeri temsil eder. Bu alan sabittir.
NegativeInfinity	Negatif sonsuzluğu temsil eder. Bu alan sabittir.
NegativeZero	Negatif sıfır sayısını (-0) temsil eder.
Pi	Bir dairenin çevresinin, π sabiti tarafından belirtilen çapına oranını temsil eder.
PositiveInfinity	Pozitif sonsuzluğu temsil eder. Bu alan sabittir.
Tau	τ sabiti tarafından belirtilen radyan sayısını tek seferde temsil eder.

Yöntemler

Name	Description
Abs(Double)	Bir değerin mutlak değerini hesaplar.
Acos(Double)	Bir değerin ark kosinüsünü hesaplar.
Acosh(Double)	Bir değerin hiperbolik ark kosinüsünü hesaplar.
AcosPi(Double)	Bir değerin ark kosinüsünü hesaplar ve sonucu ile piböler.
Asin(Double)	Bir değerin ark sinüsünü hesaplar.
Asinh(Double)	Bir değerin hiperbolik ark sinüsünü hesaplar.
AsinPi(Double)	Bir değerin ark sinüsünü hesaplar ve sonucu ile piböler.
Atan(Double)	Bir değerin yay tanjantını hesaplar.
Atan2(Double, Double)	İki değerin bölümünün ark tanjantını hesaplar.
Atan2Pi(Double, Double)	İki değerin bölümünün arc tanjantını hesaplar ve sonucu ile piböler.
Atanh(Double)	Bir değerin hiperbolik ark tanjantını hesaplar.
AtanPi(Double)	Bir değerin yay tanjantını hesaplar ve sonucu pi'ye böler.
BitDecrement(Double)	Belirtilen değerden daha azını karşılaştıran en büyük değeri döndürür.
BitIncrement(Double)	Belirtilen değerden büyük olan en küçük değeri döndürür.
Cbrt(Double)	Bir değerin küp kökünü hesaplar.
Ceiling(Double)	Bir değerin tavanını hesaplar.
Clamp(Double, Double, Double)	Bir değeri kapsayıcı en düşük ve en yüksek değere kelepçeler.
ClampNative(Double, Double, Double)	ve NaNiçin platforma özgü davranışı kullanarak bir değeri kapsayıcı bir minimum ve maksimum değere NegativeZero bağlar.
CompareTo(Double)	Bu örneği belirtilen çift duyarlıklı kayan noktalı sayıyla karşılaştırır ve bu örneğin değerinin belirtilen çift duyarlıklı kayan nokta sayısının değerinden küçük, eşit veya daha büyük olup olmadığını gösteren bir tamsayı döndürür.
CompareTo(Object)	Bu örneği belirtilen bir nesneyle karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
ConvertToInteger<TInteger>(Double)	Taşmada doygunluk kullanarak bir değeri belirtilen tamsayı türüne dönüştürür
ConvertToIntegerNative<TInteger>(Double)	Taşmada platforma özgü davranışı kullanarak bir değeri belirtilen tamsayı türüne dönüştürür.
CopySign(Double, Double)	Bir değerin işaretini başka bir değerin işaretine kopyalar.
Cos(Double)	Bir değerin kosinüsünü hesaplar.
Cosh(Double)	Bir değerin hiperbolik kosinüsünü hesaplar.
CosPi(Double)	tarafından pikatlanmış bir değerin kosinüsünü hesaplar.
CreateChecked<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için taşma özel durumu oluşturur.
CreateSaturating<TOther>(TOther)	Bir değerden geçerli türün bir örneğini oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri doygun hale getirir.
CreateTruncating<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri kesebilir.
DegreesToRadians(Double)	Verilen değeri derecelerden radyana dönüştürür.
Equals(Double)	Bu örneğin ve belirtilen Double nesnenin aynı değeri temsil edip etmediğini belirten bir değer döndürür.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
Exp(Double)	Belirli bir güce yükseltilmiş hesaplamalar E .
Exp10(Double)	Belirli bir güce yükseltilmiş hesaplamalar 10 .
Exp10M1(Double)	10 Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
Exp2(Double)	Belirli bir güce yükseltilmiş hesaplamalar 2 .
Exp2M1(Double)	2 Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
ExpM1(Double)	E Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
Floor(Double)	Bir değerin tabanını hesaplar.
FusedMultiplyAdd(Double, Double, Double)	Üç değerin birleşik çarpımını hesaplar.
GetHashCode()	Bu örneğin karma kodunu döndürür.
GetTypeCode()	değer türü TypeCodeiçin değerini Double döndürür.
Hypot(Double, Double)	Dik açılı üçgendeki kısa kenarların uzunluklarını temsil eden iki değer verilen hipotenüs hesaplar.
Ieee754Remainder(Double, Double)	IEEE 754 tarafından belirtilen iki değerin geri kalanını hesaplar.
ILogB(Double)	Bir değerin tamsayı logaritmasını hesaplar.
IsEvenInteger(Double)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
IsFinite(Double)	Belirtilen değerin sonlu (sıfır, normal altı veya normal) olup olmadığını belirler.
IsInfinity(Double)	Belirtilen sayının negatif mi yoksa pozitif sonsuz mu olduğunu belirten bir değer döndürür.
IsInteger(Double)	Bir değerin bir tamser değeri temsil eder olup olmadığını belirler.
IsNaN(Double)	Belirtilen değerin sayı (NaN) olup olmadığını gösteren bir değer döndürür.
IsNegative(Double)	Belirtilen değerin negatif olup olmadığını belirler.
IsNegativeInfinity(Double)	Belirtilen sayının negatif sonsuz olarak değerlendirilip değerlendirilmediğini belirten bir değer döndürür.
IsNormal(Double)	Belirtilen değerin normal olup olmadığını belirler.
IsOddInteger(Double)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
IsPositive(Double)	Bir değerin pozitif olup olmadığını belirler.
IsPositiveInfinity(Double)	Belirtilen sayının pozitif sonsuz olarak değerlendirilip değerlendirilmediğini belirten bir değer döndürür.
IsPow2(Double)	Bir değerin ikinin gücü olup olmadığını belirler.
IsRealNumber(Double)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
IsSubnormal(Double)	Belirtilen değerin normalin altında olup olmadığını belirler.
Lerp(Double, Double, Double)	Verilen ağırlığa göre iki değer arasında doğrusal ilişkilendirme gerçekleştirir.
Log(Double, Double)	Belirtilen tabandaki bir değerin logaritması hesaplanır.
Log(Double)	Bir değerin doğal (base-E logaritması) hesaplar.
Log10(Double)	Bir değerin 10 tabanındaki logaritması hesaplar.
Log10P1(Double)	Bir değerin ve bir değerin 10 tabanındaki logaritması hesaplar.
Log2(Double)	Bir değerin 2. günlüğünü hesaplar.
Log2P1(Double)	Bir değerin ve bir değerin 2 tabanındaki logaritması hesaplar.
LogP1(Double)	Bir değerin ve bir değerin doğal (base-E) logaritması hesaplanır.
Max(Double, Double)	daha büyük olan iki değeri işlemle karşılaştırır.
MaxMagnitude(Double, Double)	daha büyük olan iki değeri işlemle karşılaştırır.
MaxMagnitudeNumber(Double, Double)	İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.
MaxNative(Double, Double)	ve NaNiçin platforma özgü davranış kullanılarak daha yüksek olan iki değeri işlemle NegativeZero karşılaştırır.
MaxNumber(Double, Double)	daha büyük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
Min(Double, Double)	daha az olan iki değeri işlemle karşılaştırır.
MinMagnitude(Double, Double)	daha az olan iki değeri işlemle karşılaştırır.
MinMagnitudeNumber(Double, Double)	daha az büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
MinNative(Double, Double)	ve NaNiçin platforma özgü davranış kullanılarak daha az olan iki değeri işlemle NegativeZero karşılaştırır.
MinNumber(Double, Double)	daha küçük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
MultiplyAddEstimate(Double, Double, Double)	(left * right) + addendtahminini hesaplar.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini içeren karakter aralığını çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, IFormatProvider)	Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, NumberStyles, IFormatProvider)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, NumberStyles)	Belirtilen stildeki bir sayının dize gösterimini, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String)	Bir sayının dize gösterimini çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Pow(Double, Double)	Belirli bir güce yükseltilmiş bir değeri hesaplar.
RadiansToDegrees(Double)	Verilen değeri radyandan dereceye dönüştürür.
ReciprocalEstimate(Double)	Bir değerin karşılıklı tahminini hesaplar.
ReciprocalSqrtEstimate(Double)	Bir değerin karşılıklı karekökünün tahminini hesaplar.
RootN(Double, Int32)	Bir değerin n. kökünü hesaplar.
Round(Double, Int32, MidpointRounding)	Varsayılan yuvarlama modunu (ToEven) kullanarak değeri belirtilen sayıda kesirli basamağı yuvarlar.
Round(Double, Int32)	Varsayılan yuvarlama modunu (ToEven) kullanarak değeri belirtilen sayıda kesirli basamağı yuvarlar.
Round(Double, MidpointRounding)	Belirtilen yuvarlama modunu kullanarak bir değeri en yakın tamsayıya yuvarlar.
Round(Double)	Varsayılan yuvarlama modunu (ToEven) kullanarak bir değeri en yakın tamsayıya yuvarlar.
ScaleB(Double, Int32)	Bir değerin çarpımını ve belirtilen güce yükseltilmiş taban-radiksini hesaplar.
Sign(Double)	Bir değerin işaretini hesaplar.
Sin(Double)	Bir değerin sinüsünü hesaplar.
SinCos(Double)	Bir değerin sinüsünü ve kosinüsünü hesaplar.
SinCosPi(Double)	Bir değerin sinüsünü ve kosinüsünü hesaplar.
Sinh(Double)	Bir değerin hiperbolik sinüsünü hesaplar.
SinPi(Double)	ile piçarpılmış bir değerin sinüsünü hesaplar.
Sqrt(Double)	Bir değerin karekökünü hesaplar.
Tan(Double)	Bir değerin tanjantını hesaplar.
Tanh(Double)	Bir değerin hiperbolik tanjantını hesaplar.
TanPi(Double)	tarafından pikatlanmış bir değerin tanjantını hesaplar.
ToString()	Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçim bilgilerini kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Belirtilen biçimi kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
Truncate(Double)	Bir değeri kısaltılır.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli çift örneğin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Byte>, Double)	Bir sayının dize gösterimini içeren UTF-8 karakter aralığını çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürmeye çalışır.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, Double)	Bir sayının belirtilen stil ve kültüre özgü biçimdeki span gösterimini, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini içeren karakter aralığını, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(String, Double)	Bir sayının dize gösterimini çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(String, IFormatProvider, Double)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(String, NumberStyles, IFormatProvider, Double)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini, çift duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.

İşleçler

Name	Description
Equality(Double, Double)	Belirtilen Double iki değerin eşit olup olmadığını gösteren bir değer döndürür.
GreaterThan(Double, Double)	Belirtilen değerin başka Double bir belirtilen Double değerden büyük olup olmadığını gösteren bir değer döndürür.
GreaterThanOrEqual(Double, Double)	Belirtilen değerin başka Double bir belirtilen Double değerden büyük veya buna eşit olup olmadığını gösteren bir değer döndürür.
Inequality(Double, Double)	Belirtilen Double iki değerin eşit olup olmadığını gösteren bir değer döndürür.
LessThan(Double, Double)	Belirtilen değerin başka Double bir belirtilen Double değerden küçük olup olmadığını gösteren bir değer döndürür.
LessThanOrEqual(Double, Double)	Belirtilen değerin başka Double bir belirtilen Double değerden küçük veya buna eşit olup olmadığını gösteren bir değer döndürür.

Belirtik Arabirim Kullanımları

Name	Description
IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditiveIdentity<Double,Double>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IBinaryNumber<Double>.AllBitsSet	Tüm bitlerin ayarlandığı ikili türün bir örneğini alır.
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	İki değerin bit düzeyinde ve değerini hesaplar.
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	bit düzeyinde veya iki değeri hesaplar.
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	İki değerin özel veya özel değerini hesaplar.
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	Belirli bir değerin bire tamamlayan gösterimini hesaplar.
IConvertible.ToBoolean(IFormatProvider)	Bu üyenin açıklaması için bkz ToBoolean(IFormatProvider). .
IConvertible.ToByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToByte(IFormatProvider). .
IConvertible.ToChar(IFormatProvider)	Bu dönüştürme desteklenmez. Bu yöntemi kullanmaya çalışmak bir InvalidCastExceptionoluşturur.
IConvertible.ToDateTime(IFormatProvider)	Bu dönüştürme desteklenmez. Bu yöntemi kullanmaya çalışmak bir InvalidCastExceptionoluşturur.
IConvertible.ToDecimal(IFormatProvider)	Bu üyenin açıklaması için bkz ToDecimal(IFormatProvider). .
IConvertible.ToDouble(IFormatProvider)	Bu üyenin açıklaması için bkz ToDouble(IFormatProvider). .
IConvertible.ToInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt16(IFormatProvider). .
IConvertible.ToInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt32(IFormatProvider). .
IConvertible.ToInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt64(IFormatProvider). .
IConvertible.ToSByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToSByte(IFormatProvider). .
IConvertible.ToSingle(IFormatProvider)	Bu üyenin açıklaması için bkz ToSingle(IFormatProvider). .
IConvertible.ToType(Type, IFormatProvider)	Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider). .
IConvertible.ToUInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider). .
IConvertible.ToUInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider). .
IConvertible.ToUInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider). .
IDecrementOperators<Double>.Decrement(Double)	Bir değeri azaltma.
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	Kendi bölümünü hesaplamak için bir değeri diğerine böler.
IFloatingPoint<Double>.GetExponentByteCount()	bir parçası TryWriteExponentLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IFloatingPoint<Double>.GetExponentShortestBitLength()	Geçerli üssün en kısa iki tamamlayıcı gösteriminin uzunluğunu bit cinsinden alır.
IFloatingPoint<Double>.GetSignificandBitLength()	Geçerli işaret işaretinin bit cinsinden uzunluğunu alır.
IFloatingPoint<Double>.GetSignificandByteCount()	bir parçası TryWriteSignificandLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Geçerli üs büyük endian biçiminde belirli bir yayılmaya yazmaya çalışır.
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Geçerli üssü küçük endian biçiminde belirli bir süreye yazmaya çalışır.
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Geçerli işaret işaretini büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Geçerli işaret işaretini küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IFloatingPointConstants<Double>.E	matematiksel sabitini ealır.
IFloatingPointConstants<Double>.Pi	matematiksel sabitini pialır.
IFloatingPointConstants<Double>.Tau	matematiksel sabitini taualır.
IFloatingPointIeee754<Double>.Epsilon	ile sonuçlanmayan 0öğesine 0 eklenebilen en küçük değeri alır.
IFloatingPointIeee754<Double>.NaN	öğesini temsil NaNeden bir değer alır.
IFloatingPointIeee754<Double>.NegativeInfinity	Negatif infinitydeğerini temsil eden bir değer alır.
IFloatingPointIeee754<Double>.NegativeZero	Negatif zerodeğerini temsil eden bir değer alır.
IFloatingPointIeee754<Double>.PositiveInfinity	Pozitif infinitydeğerini temsil eden bir değer alır.
IIncrementOperators<Double>.Increment(Double)	Bir değeri artırır.
IMinMaxValue<Double>.MaxValue	Geçerli türün en büyük değerini alır.
IMinMaxValue<Double>.MinValue	Geçerli türün en düşük değerini alır.
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	Modüllerini veya kalan değerlerini hesaplamak için iki değeri birbirine böler.
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
INumberBase<Double>.IsCanonical(Double)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<Double>.IsComplexNumber(Double)	Bir değerin karmaşık bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Double>.IsImaginaryNumber(Double)	Bir değerin saf bir sanal sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Double>.IsZero(Double)	Değerin sıfır olup olmadığını belirler.
INumberBase<Double>.One	Türün değerini 1 alır.
INumberBase<Double>.Radix	Türün radiksini veya tabanını alır.
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	Çift duyarlıklı kayan nokta sayısını temsil eder.
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	Çift duyarlıklı kayan nokta sayısını temsil eder.
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	Çift duyarlıklı kayan nokta sayısını temsil eder.
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<Double>.Zero	Türün değerini 0 alır.
ISignedNumber<Double>.NegativeOne	Türün değerini -1 alır.
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	Farklarını hesaplamak için iki değeri çıkarır.
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	Bir değerin tekli olumsuzlamasını hesaplar.
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	Bir değerin birli artısını hesaplar.

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir. Örnek durumunu değiştirmek için görünen üyeler aslında yeni değerle başlatılan yeni bir örnek döndürür. Diğer türlerde olduğu gibi, iş parçacığı güvenliğini garanti etmek için bu türün bir örneğini içeren paylaşılan bir değişkene okuma ve yazma bir kilit tarafından korunmalıdır.

Ayrıca bkz.

• Decimal
• Single
• Örneği: .NET Core WinForms Biçimlendirme Yardımcı Programı (C#)
• Örneği: .NET Core WinForms Biçimlendirme Yardımcı Programı (Visual Basic)