Double Struktura

  • Odwołanie

Definicja

Przestrzeń nazw:
System
Zestaw:
System.Runtime.dll
Zestaw:
netstandard.dll
Zestaw:
mscorlib.dll

Reprezentuje liczbę zmiennoprzecinkową o podwójnej precyzji.

public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattable
public value class double : IComparable, IConvertible, IFormattable
public value class double : IComparable, IComparable<double>, IEquatable<double>, IFormattable
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattable
[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
public struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable
type double = struct
    interface IConvertible
    interface IFormattable
type double = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type double = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
    interface IFormattable
    interface IConvertible
type double = struct
    interface IFormattable
Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattable
Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), ISpanFormattable
Public Structure Double
Implements IComparable, IConvertible, IFormattable
Public Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable
Dziedziczenie
Object
ValueType
Double
Atrybuty
SerializableAttribute ComVisibleAttribute
Implementuje
IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable ISpanFormattable

Przykłady

Poniższy przykład kodu ilustruje użycie funkcji Double :

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double 
// implementation.
public ref class Temperature: public IComparable, public IFormattable
{
   // IComparable.CompareTo implementation.
public:
   virtual int CompareTo( Object^ obj )
   {
      if (obj == nullptr) return 1;
      
      if (dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException( "object is not a Temperature" );
   }

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

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

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

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

protected:
   double m_value;

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

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

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

      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

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

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

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

        return m_value.ToString(format, provider);
    }

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

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

        return temp;
    }

    // The value holder
    protected double m_value;

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

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

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

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

            Return m_value.CompareTo(temp.m_value)
        End If

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

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

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

        Return m_value.ToString(format, provider)
    End Function

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

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

    ' The value holder
    Protected m_value As Double

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

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

Uwagi

Typ wartości reprezentuje liczbę 64-bitową o podwójnej precyzji z wartościami od Double ujemnymi 1,79769313486232e308 do dodatnich 1,79769313486232e308, a także zerem dodatnim lub ujemnym, , , a nie liczbą PositiveInfinity NegativeInfinity ( NaN ). Jest ona przeznaczona do reprezentowania bardzo dużych wartości (takich jak odległości między planetami lub łańcami) lub bardzo małych (takich jak masa molekularna gwiazdy) i które często są niedokładne (na przykład odległość od Ziemi do innego układu słonecznego). Typ Double jest zgodny ze standardem IEC 60559:1989 (IEEE 754) dla binarnej arytmetyki zmiennoprzecinków.

Ten temat składa się z następujących sekcji:

Reprezentacja liczb zmiennoprzecinkowych i precyzja

Typ danych przechowuje wartości zmiennoprzecinkowe o podwójnej precyzji w Double 64-bitowym formacie binarnym, jak pokazano w poniższej tabeli:

Część Bity
Significand lub mantysa 0-51
Wykładnik 52-62
Znak (0 = dodatni, 1 = ujemny) 63

Tak jak ułamki dziesiętne nie mogą precyzyjnie reprezentować niektórych wartości ułamkowych (takich jak 1/3 lub ), ułamki binarne nie mogą reprezentować niektórych Math.PI wartości ułamkowych. Na przykład liczba 1/10, która jest reprezentowana dokładnie przez .1 jako ułamek dziesiętny, jest reprezentowana przez .001100110011 jako ułamek binarny, ze wzorcem "0011" powtarzanym do nieskończoności. W tym przypadku wartość zmiennoprzecinkowa zapewnia niedokładną reprezentację liczby, która reprezentuje. Wykonywanie dodatkowych operacji matematycznych na oryginalnej wartości zmiennoprzecinowej często zwiększa jej brak precyzji. Jeśli na przykład porównamy wynik pomnożenia wartości 0,1 przez 10 i dodania 0,1 do 0,1 dziewięciokrotnie, zobaczymy, że dodanie, ponieważ zawierało osiem kolejnych operacji, wyniosło mniej dokładny wynik. Należy pamiętać, że różnice te są widoczne tylko wtedy, gdy dwie wartości są wyświetlane przy użyciu ciągu standardowego formatu liczbowego "R", który w razie potrzeby wyświetla wszystkie 17 cyfr precyzji obsługiwanych przez Double Double typ.

using System;

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

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

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

Ponieważ niektóre liczby nie mogą być reprezentowane dokładnie jako ułamkowe wartości binarne, liczby zmiennoprzecinacyjne mogą być przybliżone tylko dla liczb rzeczywistych.

Wszystkie liczby zmiennoprzecinkowe mają również ograniczoną liczbę cyfr znaczących, co określa również, jak dokładnie wartość zmiennoprzecinkowa jest przybliżona dla liczby rzeczywistej. Wartość Double ma do 15 cyfr dziesiętnych precyzji, chociaż maksymalnie 17 cyfr jest utrzymywane wewnętrznie. Oznacza to, że niektóre operacje zmiennoprzecinkowe mogą nie mieć precyzji, aby zmienić wartość zmiennoprzecinkową. Poniższy przykład stanowi ilustrację. Definiuje bardzo dużą wartość zmiennoprzecinkową, a następnie dodaje do niego i produkt oraz Double.Epsilon jeden czterokropek. Produkt jest jednak zbyt mały, aby zmodyfikować oryginalną wartość zmiennoprzecinkową. Najmniej znacząca cyfra to liczba tysięsięka, a najbardziej znacząca cyfra w produkcie to10–309.

using System;

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

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

Ograniczona precyzja liczby zmiennoprzecinkowej ma kilka konsekwencji:

  • Dwie liczby zmiennoprzecinkowe, które wyglądają na równe dla określonej precyzji, mogą nie być porównywane równorzędnie, ponieważ ich najmniej znaczące cyfry są różne. W poniższym przykładzie seria liczb jest dodawana razem, a ich suma jest porównywana z oczekiwaną sumą. Mimo że te dwie wartości wydają się być takie same, wywołanie metody Equals wskazuje, że nie są.

    using System;

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

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

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

    Jeśli zmienisz elementy formatu w instrukcji z i na i w celu wyświetlenia wszystkich znaczących cyfr tych dwóch wartości, będzie jasne, że te dwie wartości są nierówne z powodu utraty dokładności podczas operacji Console.WriteLine(String, Object, Object) {0} {1} {0:R} {1:R} Double dodatku. W takim przypadku problem można rozwiązać, wywołując metodę w celu zaokrąglania wartości do żądanej precyzji Math.Round(Double, Int32) Double przed przeprowadzeniem porównania.

  • Operacja matematyczna lub porównawcza, która używa liczby zmiennoprzecinowej, może nie przynieść tego samego wyniku, jeśli jest używana liczba dziesiętna, ponieważ binarna liczba zmiennoprzecinkowa może nie być równa liczbie dziesiętnej. W poprzednim przykładzie pokazano to, wyświetlając wynik mnożenia wartości .1 przez 10 i dodawania 0,1 razy.

    Gdy dokładność operacji liczbowych z wartościami ułamkowych jest ważna, można użyć Decimal typu , a nie Double . Gdy ważna jest dokładność w operacjach liczbowych z wartościami całkowitoliczbowych wykraczających poza zakres typów lub Int64 UInt64 , użyj typu BigInteger .

  • Wartość może nie być rundą, jeśli jest w tym udział liczba zmiennoprzecinkowa. Wartość jest mówiona do rundy, jeśli operacja konwertuje oryginalną liczbę zmiennoprzecinkową na inną postać, operacja odwrotna przekształca przekonwertowany formularz z powrotem na liczbę zmiennoprzecinkową, a końcowa liczba zmiennoprzecinkowa nie jest równa oryginalnej liczbie zmiennoprzecinkowej. Runda może się nie powieść, ponieważ co najmniej jedna cyfra znacząca jest tracona lub zmieniona w konwersji. W poniższym przykładzie trzy Double wartości są konwertowane na ciągi i zapisywane w pliku. Jednak, jak widać w danych wyjściowych, mimo że wartości wydają się identyczne, przywrócone wartości nie są równe oryginalnym wartościom.

    using System;
using System.IO;

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

      Double[] restoredValues = new Double[values.Length];
      StreamReader sr = new StreamReader(@".\Doubles.dat");
      string temp = sr.ReadToEnd();
      string[] tempStrings = temp.Split('|');
      for (int ctr = 0; ctr < tempStrings.Length; ctr++)
         restoredValues[ctr] = Double.Parse(tempStrings[ctr]);

      for (int ctr = 0; ctr < values.Length; ctr++)
         Console.WriteLine("{0} {2} {1}", values[ctr],
                           restoredValues[ctr],
                           values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
   }
}
// The example displays the following output:
//       2.17821782178218 <> 2.17821782178218
//       0.333333333333333 <> 0.333333333333333
//       3.14159265358979 <> 3.14159265358979

    Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\Doubles.dat")
      Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
      For ctr As Integer = 0 To values.Length - 1
         sw.Write(values(ctr).ToString())
         If ctr <> values.Length - 1 Then sw.Write("|")
      Next      
      sw.Close()
      
      Dim restoredValues(values.Length - 1) As Double
      Dim sr As New StreamReader(".\Doubles.dat")
      Dim temp As String = sr.ReadToEnd()
      Dim tempStrings() As String = temp.Split("|"c)
      For ctr As Integer = 0 To tempStrings.Length - 1
         restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
      Next 

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

    W takim przypadku wartości można pomyślnie zaokrąglić przy użyciu ciągu standardowego formatu liczbowego "G17", aby zachować pełną precyzję wartości, jak pokazano w poniższym Double przykładzie.

    using System;
using System.IO;

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

      sw.Close();

      Double[] restoredValues = new Double[values.Length];
      StreamReader sr = new StreamReader(@".\Doubles.dat");
      string temp = sr.ReadToEnd();
      string[] tempStrings = temp.Split('|');
      for (int ctr = 0; ctr < tempStrings.Length; ctr++)
         restoredValues[ctr] = Double.Parse(tempStrings[ctr]);

      for (int ctr = 0; ctr < values.Length; ctr++)
         Console.WriteLine("{0} {2} {1}", values[ctr],
                           restoredValues[ctr],
                           values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
   }
}
// The example displays the following output:
//       2.17821782178218 = 2.17821782178218
//       0.333333333333333 = 0.333333333333333
//       3.14159265358979 = 3.14159265358979

    Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\Doubles.dat")
      Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
      For ctr As Integer = 0 To values.Length - 1
         sw.Write("{0:G17}{1}", values(ctr), 
                  If(ctr < values.Length - 1, "|", ""))
      Next      
      sw.Close()
      
      Dim restoredValues(values.Length - 1) As Double
      Dim sr As New StreamReader(".\Doubles.dat")
      Dim temp As String = sr.ReadToEnd()
      Dim tempStrings() As String = temp.Split("|"c)
      For ctr As Integer = 0 To tempStrings.Length - 1
         restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
      Next 

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

Ważne

W przypadku użycia z wartością specyfikator formatu "R" w niektórych przypadkach nie może pomyślnie Double zaokrąglić oryginalnej wartości. Aby upewnić się, że wartości Double są pomyślnie zaokrąglane, użyj specyfikatora formatu "G17".

  • Single Wartości mają mniejszą precyzję niż Double wartości. Wartość, która jest konwertowana na pozornie równoważny, często nie jest równa wartości z Single Double powodu różnic w Double dokładności. W poniższym przykładzie wynik identycznych operacji dzielenia jest przypisywany do wartości Double Single i . Po rzutowania wartości na wartość porównanie dwóch wartości pokazuje, że Single Double są nierówne.

    using System;

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

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

    Aby uniknąć tego problemu, użyj typu danych w miejsce lub metody , aby obie wartości Double Single były takie Round same.

Ponadto wynik operacji arytmetycznych i przypisań z wartościami może się nieznacznie różnić w zależności od platformy ze względu na utratę Double dokładności Double typu. Na przykład wynik przypisania wartości literału może się różnić w Double 32-bitowych i 64-bitowych wersjach .NET Framework. Poniższy przykład ilustruje tę różnicę, gdy wartość literału -4.42330604244772E-305 i zmienna o wartości -4.42330604244772E-305 są przypisane do Double zmiennej. Należy pamiętać, że wynik metody w tym Parse(String) przypadku nie powoduje utraty dokładności.

double value = -4.42330604244772E-305;

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

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

Dim value As Double = -4.42330604244772E-305

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

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

Testowanie pod kątem równości

Aby można je było uznać za równe, Double dwie wartości muszą reprezentować identyczne wartości. Jednak z powodu różnic w dokładności między wartościami lub z powodu utraty dokładności przez jedną lub obie wartości wartości zmiennoprzecinkowe, które powinny być identyczne, często okazuje się być nierówne ze względu na różnice w ich najmniej znaczących cyfrach. W związku z tym metoda wywołuje metodę w celu określenia, czy dwie wartości są równe, lub wywołuje metodę w celu określenia relacji między dwiema wartościami, często Equals CompareTo daje Double nieoczekiwane wyniki. Jest to oczywiste w poniższym przykładzie, gdzie dwie wyraźnie równe wartości okazuje się nierówne, ponieważ pierwsza ma 15 cyfr dokładności, a druga Double 17.

using System;

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

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

Wartości obliczane, które podążają różnymi ścieżkami kodu i są manipulowane na różne sposoby, często okazują się nierówne. W poniższym przykładzie jedna wartość jest kwadratem, a następnie pierwiastek kwadratowy jest obliczany w Double celu przywrócenia oryginalnej wartości. Sekunda jest mnożona przez 3,51 i do kwadratu przed pierwiastek kwadratowy wyniku jest dzielony przez Double 3,51, aby przywrócić oryginalną wartość. Mimo że te dwie wartości wydają się być identyczne, wywołanie metody Equals(Double) wskazuje, że nie są równe. Użycie ciągu formatu standardowego "R" w celu zwrócenia ciągu wynikowego, który wyświetla wszystkie cyfry znaczące każdej wartości typu Double, pokazuje, że druga wartość jest 0000000000001 mniejsza niż pierwsza.

using System;

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

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

W przypadkach, gdy utrata dokładności może wpłynąć na wynik porównania, można przyjąć dowolną z następujących alternatyw do wywoływania Equals CompareTo metody lub :

  • Wywołaj Math.Round metodę , aby upewnić się, że obie wartości mają taką samą precyzję. W poniższym przykładzie zmodyfikuje poprzedni przykład, aby użyć tego podejścia, tak aby dwie wartości ułamkowe były równoważne.

    using System;

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

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

    Problem dokładności nadal dotyczy zaokrąglania wartości punktu środkowego. Aby uzyskać więcej informacji, zobacz Math.Round(Double, Int32, MidpointRounding) metodę .

  • Przetestuj przybliżoną równość, a nie równość. Wymaga to zdefiniowania wartości bezwzględnej, o którą te dwie wartości mogą się różnić, ale nadal być równe, lub zdefiniowania względnej ilości, o którą mniejsza wartość może różnić się od większej wartości.

    Ostrzeżenie

    Double.Epsilon Jest czasami używany jako bezwzględna miara odległości między dwiema Double wartościami podczas testowania równości. Jednak mierzy najmniejszą możliwą wartość, która może zostać dodana do lub odjęta Double.Epsilon od, której Double wartość wynosi zero. W przypadku większości wartości dodatnich i Double ujemnych wartość jest Double.Epsilon zbyt mała, aby można było jej wykryć. W związku z tym, z wyjątkiem wartości, które są równe zero, nie zaleca się ich użycia w testach równości.

    W poniższym przykładzie użyto drugiego podejścia do zdefiniowania IsApproximatelyEqual metody, która testuje względną różnicę między dwiema wartościami. Kontrastuje również wynik wywołań metody IsApproximatelyEqual i Equals(Double) metody .

    using System;

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

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

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

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

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

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

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

   Function IsApproximatelyEqual(value1 As Double, value2 As Double, 
                                 epsilon As Double) As Boolean
      ' If they are equal anyway, just return True.
      If value1.Equals(value2) Then Return True
      
      ' Handle NaN, Infinity.
      If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then
         Return value1.Equals(value2)
      Else If Double.IsInfinity(value2) Or Double.IsNaN(value2)
         Return value1.Equals(value2)
      End If
      
      ' Handle zero to avoid division by zero
      Dim divisor As Double = Math.Max(value1, value2)
      If divisor.Equals(0) Then
         divisor = Math.Min(value1, value2)
      End If 
      
      Return Math.Abs((value1 - value2) / divisor) <= epsilon           
   End Function
End Module
' The example displays the following output:
'       1 = 0.99999999999999989: False
'       1 is approximately equal to 0.99999999999999989: True

Wartości zmiennoprzecinkowe i wyjątki

W przeciwieństwie do operacji z typami całkowitoprzecinjącymi, które zwracają wyjątki w przypadkach przepełnienia lub niedozwolonych operacji, takich jak dzielenie przez zero, operacje z wartościami zmiennoprzecinkową nie zwracają wyjątków. Zamiast tego w szczególnych sytuacjach wynik operacji zmiennoprzecinków wynosi zero, nieskończoność dodatnia, nieskończoność ujemna lub nie jest liczbą (NaN):

  • Jeśli wynik operacji zmiennoprzecinowej jest zbyt mały dla formatu docelowego, wynik wynosi zero. Może się to zdarzyć, gdy zostaną pomnożone dwie bardzo małe liczby, jak pokazano w poniższym przykładzie.

    using System;

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

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

  • Jeśli wielkość wyniku operacji zmiennoprzecinkowej przekracza zakres formatu docelowego, wynikiem operacji jest lub , odpowiednio dla znaku PositiveInfinity NegativeInfinity wyniku. Wynikiem operacji przepełnianej jest , a wynikiem operacji, która przepełnia, jest , jak pokazano w Double.MaxValue PositiveInfinity poniższym Double.MinValue NegativeInfinity przykładzie.

    using System;

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

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

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

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

    PositiveInfinity również wynika z dzielenia przez zero z dodatnią dzielną i wynika z dzielenia przez NegativeInfinity zero z ujemną dzielną.

  • Jeśli operacja zmiennoprzecinkowa jest nieprawidłowa, wynikiem operacji jest NaN . Na przykład NaN wyniki z następujących operacji:

    • Dzielenie przez zero z dzielną o wartości zero. Należy pamiętać, że inne przypadki dzielenia przez zero są wynikiem PositiveInfinity wartości lub NegativeInfinity .

  • Dowolna operacja zmiennoprzecinkowa z nieprawidłowymi danych wejściowych. Na przykład wywołanie metody z wartością ujemną zwraca wartość , podobnie jak wywołanie metody z wartością, która jest większa niż jedna lub mniejsza Math.Sqrt NaN niż wartość Math.Acos ujemna.

  • Dowolna operacja z argumentem, którego wartość to Double.NaN .

Konwersje typów i struktura Double

Struktura nie definiuje żadnych jawnych ani niejawnych operatorów Double konwersji; zamiast tego konwersje są implementowane przez kompilator.

Konwersja wartości dowolnego pierwotnego typu liczbowego na typ jest konwersją poszerzania i dlatego nie wymaga jawnego operatora rzutowania ani wywołania metody konwersji, chyba że kompilator jawnie Double tego wymaga. Na przykład kompilator języka C# wymaga operatora rzutowania do konwersji z na , podczas gdy kompilator Decimal Double Visual Basic nie. W poniższym przykładzie wartość minimalna lub maksymalna innych pierwotnych typów liczbowych jest konwertowana na Double wartość .

using System;

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

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

Ponadto wartości , Single i są Single.NaN Single.PositiveInfinity Single.NegativeInfinity konwertowane odpowiednio na Double.NaN Double.PositiveInfinity wartości , i Double.NegativeInfinity .

Należy pamiętać, że konwersja wartości niektórych typów liczbowych na wartość może Double wiązać się z utratą dokładności. Jak pokazano w przykładzie, utrata dokładności jest możliwa podczas konwertowania Decimal wartości , i na Int64 UInt64 Double wartości.

Konwersja wartości na wartość dowolnego innego pierwotnego typu danych liczbowych jest konwersją zawężaną i wymaga operatora rzutowania (w języku C#), metody konwersji (w języku Visual Basic) lub wywołania Double Convert metody. Wartości spoza zakresu docelowego typu danych, które są definiowane przez właściwości i typ docelowy, zachowują się tak, jak pokazano w MinValue MaxValue poniższej tabeli.

Typ docelowy Wynik
Dowolny typ całkowito-całkowitocowy OverflowExceptionWyjątek, jeśli konwersja ma miejsce w sprawdzonym kontekście.

Jeśli konwersja odbywa się w niesprawdzonym kontekście (wartość domyślna w języku C#), operacja konwersji powiedzie się, ale wartość zostanie przepełniona.
Decimal OverflowExceptionWyjątek.
Single Single.NegativeInfinity w przypadku wartości ujemnych.

Single.PositiveInfinity w przypadku wartości dodatnich.

Ponadto , i zgłaszają dla konwersji na liczby całkowite w kontekście sprawdzane, ale te wartości przepełniają się w przypadku konwersji na liczby całkowite w Double.NaN Double.PositiveInfinity Double.NegativeInfinity OverflowException kontekście niezaznaczonej. W przypadku konwersji Decimal na element zawsze zgłaszany jest element OverflowException . W przypadku konwersji na , konwertują odpowiednio na Single , i Single.NaN Single.PositiveInfinity Single.NegativeInfinity .

Należy pamiętać, że utrata dokładności może wynikać z konwersji wartości Double na inny typ liczbowy. W przypadku konwersji na dowolny typ całkowitoliczbowy, jak pokazano w przykładzie, składnik ułamkowy jest utracony, gdy wartość jest zaokrąglona (jak w Visual Basic) lub obcinana (jak w Double języku C#). W przypadku konwersji na wartości i wartość może nie mieć dokładnej reprezentacji Decimal Single w docelowym Double typie danych.

W poniższym przykładzie liczba wartości jest Double konwertowana na kilka innych typów liczbowych. Konwersje występują w sprawdzonym kontekście w Visual Basic (ustawienie domyślne) i w języku C# (ze względu na sprawdzone słowo kluczowe). Dane wyjściowe z przykładu pokazują wynik konwersji w obu przypadkach zaznaczonego niezaznaczonego kontekstu. Konwersje w niesprawdzonym kontekście można wykonać w Visual Basic, kompilując z przełącznikiem kompilatora i w języku /removeintchecks+ C#, komentowając tę checked instrukcje.

using System;

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

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

Aby uzyskać więcej informacji na temat konwersji typów liczbowych, zobacz Konwersja typów w tabelach .NET Framework i Type Conversion.

Funkcje zmiennoprzecinkowe

Struktura Double i powiązane typy zapewniają metody wykonywania operacji w następujących obszarach:

  • Porównanie wartości. Możesz wywołać metodę , aby określić, czy dwie wartości są równe, lub metodę w celu określenia Equals Double CompareTo relacji między dwiema wartościami.

    Struktura Double obsługuje również kompletny zestaw operatorów porównania. Można na przykład przetestować równość lub nierówność albo określić, czy jedna wartość jest większa, czy równa innej. Jeśli jeden z operandów jest typem liczbowym innym niż , jest on konwertowany na Double argument przed Double wykonaniem porównania.

    Ostrzeżenie

    Ze względu na różnice w dokładności dwie wartości, które powinny być równe, mogą okazać się nierówne, co wpływa na Double wynik porównania. Zobacz sekcję Testing for Equality (Testowanie pod względem równości), aby uzyskać więcej informacji na temat porównywania dwóch Double wartości.

    Możesz również wywołać metody IsNaN , , i , aby IsInfinity IsPositiveInfinity IsNegativeInfinity przetestować te wartości specjalne.

  • Operacje matematyczne. Typowe operacje arytmetyczne, takie jak dodawanie, odejmowanie, mnożenie i dzielenie, są implementowane przez kompilatory języka i instrukcje cil (Common Intermediate Language), a nie Double metody. Jeśli jeden z operandów w operacji matematycznej jest typem liczbowym innym niż , jest on konwertowany na Double argument przed Double wykonaniem operacji. Wynik operacji jest również Double wartością.

    Inne operacje matematyczne można wykonać przez wywołanie static metody ( Shared w Visual Basic) w System.Math klasie. Zawiera on dodatkowe metody często używane do arytmetyki (takich jak Math.Abs Math.Sign , i ), geometrii (takich jak i ) oraz rachunku Math.Sqrt Math.Cos Math.Sin (takiego jak Math.Log ).

    Można również manipulować poszczególnymi bitami w Double wartości. Metoda BitConverter.DoubleToInt64Bits zachowuje wzorzec Double bitowy wartości w 64-bitowej całkowitej. Metoda BitConverter.GetBytes(Double) zwraca wzorzec bitowy w tablicy bajtów.

  • Zaokrąglanie . Zaokrąglanie jest często używane jako technika zmniejszania wpływu różnic między wartościami spowodowanych przez problemy z reprezentacją zmiennoprzecinkową i precyzją. Wartość można Double zaokrąglić, wywołując Math.Round metodę .

  • Formatowanie. Wartość można przekonwertować na jej reprezentację w Double postaci ciągu, wywołując ToString metodę lub używając funkcji formatowania złożonego. Aby uzyskać informacje o tym, jak ciągi formatowe kontrolują reprezentację ciągów wartości zmiennoprzecinkowe, zobacz tematy Standardowe ciągi formatów liczbowych i Niestandardowe ciągi formatów liczbowych.

  • Analizowanie ciągów. Reprezentację ciągu wartości zmiennoprzecinkowej można przekonwertować na wartość, Double wywołując metodę Parse lub TryParse . Jeśli operacja analizy zakończy się niepowodzeniem, Parse metoda zgłasza wyjątek, natomiast metoda zwraca wartość TryParse false .

  • Konwersja typu. Struktura Double zapewnia jawną implementację interfejsu IConvertible dla interfejsu, która obsługuje konwersję między dowolnymi dwoma standardowymi .NET Framework typami danych. Kompilatory języka obsługują również niejawną konwersję wartości wszystkich innych standardowych typów liczbowych na Double wartości. Konwersja wartości dowolnego standardowego typu liczbowego na wartość jest konwersją poszerzaną i nie wymaga użytkownika Double operatora rzutowania ani metody konwersji.

    Jednak konwersja Int64 wartości i może Single wiązać się z utratą dokładności. W poniższej tabeli wymieniono różnice w dokładności dla każdego z tych typów:

    Typ Maksymalna precyzja Precyzja wewnętrzna
    Double 15 17
    Int64 19 cyfr dziesiętnych 19 cyfr dziesiętnych
    Single 7 cyfr dziesiętnych 9 cyfr dziesiętnych

    Problem dokładności najczęściej ma wpływ na Single wartości, które są konwertowane na Double wartości. W poniższym przykładzie dwie wartości produkowane przez identyczne operacje dzielenia są nierówne, ponieważ jedna z tych wartości jest wartością zmiennoprzecinkową o pojedynczej precyzji przekonwertowaną na Double .

    using System;

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

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

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

Pola

Epsilon

Reprezentuje najmniejszą wartość Double dodatnią, która jest większa od zera. To pole jest stałe.
MaxValue

Reprezentuje największą możliwą wartość Double . To pole jest stałe.
MinValue

Reprezentuje najmniejszą możliwą Double wartość . To pole jest stałe.
NaN

Reprezentuje wartość, która nie jest liczbą ( NaN ). To pole jest stałe.
NegativeInfinity

Reprezentuje nieskończoność ujemną. To pole jest stałe.
PositiveInfinity

Reprezentuje nieskończoność dodatnią. To pole jest stałe.

Metody

CompareTo(Double)

Porównuje to wystąpienie z określoną liczbą zmiennoprzecinkową o podwójnej precyzji i zwraca liczbę całkowitą wskazującą, czy wartość tego wystąpienia jest mniejsza, równa lub większa niż określona liczba zmiennoprzecinkowa podwójnej precyzji.
CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza, równa lub większa niż wartość określonego obiektu.
Equals(Double)

Zwraca wartość wskazującą, czy to wystąpienie i określony Double obiekt reprezentują tę samą wartość.
Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.
GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.
GetTypeCode()

Zwraca typ TypeCode wartości Double dla .
IsFinite(Double)

Określa, czy określona wartość jest skończona (zero, subnormal, lub normalny).
IsInfinity(Double)

Zwraca wartość wskazującą, czy określona liczba ma wartość ujemną, czy dodatnią nieskończoność.
IsNaN(Double)

Zwraca wartość, która wskazuje, czy określona wartość nie jest liczbą ( NaN ).
IsNegative(Double)

Określa, czy określona wartość jest ujemna.
IsNegativeInfinity(Double)

Zwraca wartość wskazującą, czy określona liczba ma wartość ujemną nieskończoności.
IsNormal(Double)

Określa, czy określona wartość jest normalna.
IsPositiveInfinity(Double)

Zwraca wartość wskazującą, czy określona liczba daje w stanie nieskończoność dodatnią.
IsSubnormal(Double)

Określa, czy określona wartość jest subnormalna.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konwertuje zakres znaków zawierający reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej podwójnej precyzji.
Parse(String)

Konwertuje ciąg reprezentujący liczbę na odpowiadającą mu liczbę zmiennoprzecinkową podwójnej precyzji.
Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej o podwójnej precyzji.
Parse(String, NumberStyles)

Konwertuje reprezentację ciągu liczby w określonym stylu na równoważnik liczby zmiennoprzecinkowej podwójnej precyzji.
Parse(String, NumberStyles, IFormatProvider)

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej podwójnej precyzji.
ToString()

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.
ToString(IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.
ToString(String)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.
ToString(String, IFormatProvider)

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Próbuje sformatować wartość bieżącego podwójnego wystąpienia do podanego zakresu znaków.
TryParse(ReadOnlySpan<Char>, Double)

Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej podwójnej precyzji. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)

Konwertuje zakres znaków zawierający reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej podwójnej precyzji. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.
TryParse(String, Double)

Konwertuje ciąg reprezentujący liczbę na odpowiadającą mu liczbę zmiennoprzecinkową podwójnej precyzji. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.
TryParse(String, NumberStyles, IFormatProvider, Double)

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na równoważnik liczby zmiennoprzecinkowej o podwójnej precyzji. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

Operatory

Equality(Double, Double)

Zwraca wartość, która wskazuje, czy dwie określone Double wartości są równe.
GreaterThan(Double, Double)

Zwraca wartość, która wskazuje, czy Double określona wartość jest większa niż inna Double określona wartość.
GreaterThanOrEqual(Double, Double)

Zwraca wartość, która wskazuje, czy określona wartość jest większa niż lub Double równa innej określonej Double wartości.
Inequality(Double, Double)

Zwraca wartość, która wskazuje, czy dwie określone Double wartości nie są równe.
LessThan(Double, Double)

Zwraca wartość, która wskazuje, czy Double określona wartość jest mniejsza niż inna Double określona wartość.
LessThanOrEqual(Double, Double)

Zwraca wartość, która wskazuje, czy określona wartość jest mniejsza niż lub Double równa innej określonej Double wartości.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.
IConvertible.GetTypeCode()

Zwraca wartość TypeCode dla tego wystąpienia.
IConvertible.ToBoolean(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToBoolean(IFormatProvider) .
IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToByte(IFormatProvider) .
IConvertible.ToChar(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza wyjątek InvalidCastException .
IConvertible.ToDateTime(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza wyjątek InvalidCastException .
IConvertible.ToDecimal(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDecimal(IFormatProvider) .
IConvertible.ToDouble(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDouble(IFormatProvider) .
IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt16(IFormatProvider) .
IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt32(IFormatProvider) .
IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt64(IFormatProvider) .
IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSByte(IFormatProvider) .
IConvertible.ToSingle(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSingle(IFormatProvider) .
IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToType(Type, IFormatProvider) .
IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt16(IFormatProvider) .
IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt32(IFormatProvider) .
IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt64(IFormatProvider) .

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.

Zobacz też