이 문서는 기계 번역을 이용하여 번역되었습니다. 문서를 영문으로 보려면 영문 확인란을 선택하세요. 마우스 포인터를 텍스트 위로 이동시켜 팝업 창에서 영문 텍스트를 표시할 수도 있습니다.
번역
영문

Double 구조체

 

배정밀도 부동 소수점 숫자를 나타냅니다.

네임스페이스:   System
어셈블리:  mscorlib.dll의 mscorlib

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, IConvertible, 
	IComparable<double>, IEquatable<double>

이름설명
System_CAPS_pubmethodCompareTo(Double)

이 인스턴스를 지정된 배정밀도 부동 소수점 숫자와 비교하고 이 인스턴스의 값이 지정된 배정밀도 부동 소수점 숫자 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.

System_CAPS_pubmethodCompareTo(Object)

이 인스턴스를 지정된 개체와 비교하고 이 인스턴스의 값이 지정된 개체의 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.

System_CAPS_pubmethodEquals(Double)

이 인스턴스의 값과 지정된 Double 개체의 값이 같은지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodEquals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.(ValueType.Equals(Object)을(를) 재정의함)

System_CAPS_pubmethodGetHashCode()

이 인스턴스의 해시 코드를 반환합니다.(ValueType.GetHashCode()을(를) 재정의함)

System_CAPS_pubmethodGetType()

현재 인스턴스의 Type을 가져옵니다.(Object에서 상속됨.)

System_CAPS_pubmethodGetTypeCode()

TypeCode 값 형식에 대한 Double를 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Double)

지정된 숫자가 음의 무한대로 계산되는지 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Double)

지정된 값이 숫자가 아닌지(NaN) 여부를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Double)

지정된 숫자가 음의 무한대로 계산되는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Double)

지정된 숫자가 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

숫자의 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

지정된 문화권별 형식의 숫자에 대한 문자열 표현을 해당하는 배정밀도 부동 소수점 숫자로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

지정된 스타일의 숫자에 대한 문자열 표현을 해당하는 배정밀도 부동 소수점 숫자로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

지정된 스타일 및 문화권별 형식의 숫자에 대한 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다.

System_CAPS_pubmethodToString()

이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.(ValueType.ToString()을(를) 재정의함)

System_CAPS_pubmethodToString(IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToString(String)

지정된 형식을 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToString(String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Double)

숫자의 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Double)

지정된 스타일 및 문화권별 형식의 숫자에 대한 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다.

이름설명
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

0보다 큰 양의 최소 Double 값을 나타냅니다. 이 필드는 상수입니다.

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Double의 가능한 최대값을 나타냅니다. 이 필드는 상수입니다.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Double의 최소값을 나타냅니다. 이 필드는 상수입니다.

System_CAPS_pubfieldSystem_CAPS_staticNaN

숫자가 아닌 값을 나타냅니다(NaN). 이 필드는 상수입니다.

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

음의 무한대를 나타냅니다. 이 필드는 상수입니다.

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

양의 무한대를 나타냅니다. 이 필드는 상수입니다.

이름설명
System_CAPS_puboperatorSystem_CAPS_staticEquality(Double, Double)

지정된 두 Double 값이 같은지 여부를 나타내는 값을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Double, Double)

지정된 Double 값이 지정된 다른 Double 값보다 큰지 여부를 나타내는 값을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Double, Double)

지정된 Double 값이 지정된 다른 Double 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Double, Double)

지정된 두 Double 값이 같지 않은지 여부를 나타내는 값을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Double, Double)

지정된 Double 값이 지정된 다른 Double 값보다 작은지 여부를 나타내는 값을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Double, Double)

지정된 Double 값이 지정된 다른 Double 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.

이름설명
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToBoolean를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToByte를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToDecimal를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToDouble를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToInt16를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToInt32를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToInt64를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToSByte를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToSingle를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToType를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToUInt16를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToUInt32를 참조하세요.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

이 API는 제품 인프라를 지원하지만 코드에서 직접 사용할 수는 없습니다. 이 멤버에 대한 설명은 IConvertible.ToUInt64를 참조하세요.

Double 값 형식은 음수 1.79769313486232 e 308에서 양수 또는 음수 0 뿐만 아니라 양수 1.79769313486232 e 308 까지의 값을 가진 배정밀 64 비트 숫자를 나타내는 PositiveInfinity, NegativeInfinity, 및 not-a-number (NaN). 됩니다 (예: 행성 또는 은하계 사이의 거리) 매우 큰 수 또는 매우 작은 (킬로그램에서 중심의 분자 질량)와 종종는 아닙니다 (예: 까지의 거리 지구 다른 태양계), 정확한 값을 나타내는 것은 Double 종류는 IEC 60559: 1989 (IEEE 754) 이진 부동 소수점 연산에 대 한 표준 준수 합니다.

이 항목은 다음 섹션으로 구성되어 있습니다.

Double 데이터 형식은 다음 표에 나와 있는 것 처럼 64 비트 이진 형식으로 배정밀도 부동 소수점 값을 저장 합니다.

파트

비트

유효 숫자 또는 수

0-51

지 수

52-62

기호 (0 = 1 양수, 음수 =)

63

소수 일부 소수 값을 정확 하 게 표현할 수 없는 경우와 마찬가지로 (1/3 같은 또는 Math.PI), 이진 분수를 소수로 표시 된 일부 값을 나타내는 수 없는 경우. 예를 들어, 1/10, 소수 부분으로 순서 대로.1 하 여 정확 하 게 표시 되는 패턴 "0011" 반복 무한대와 이진 소수로.001100110011으로 표시 됩니다. 이 경우 부동 소수점 값에는 표시 되는 숫자의는 정확 하지 않은 표현을 제공 합니다. 원래 부동 소수점 값에 추가적인 수치 연산을 실행 빈도가 정밀도 부족 증가 경향이 있습니다. 예를 들어. 1에서 10을 곱한 결과를 비교 하는 경우 9 번. 1. 1을 추가, 표시 추가 작업을 더 8 관련가 있기 때문에 덜 정확한 결과 생성 했습니다. 이 일치 하지이 않을 두를 표시 하는 경우에 그렇습니다는 Double "R"를 사용 하 여 값 표준 숫자 형식 문자열, 이며 필요한에서 지 원하는 전체 자릿수가 17 자리를 모두 표시 하는 경우는 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

일부 숫자는 소수 자릿수 이진 값으로 정확 하 게 표현할 수 없으므로, 부동 소수점 숫자에만 대략적인 실수 수 있습니다.

모든 부동 소수점 숫자에는 또한 제한 된 수의 유효 자릿수 부동 소수점 값을 근사치 숫자는 실수를 계산 하는 방법을 정확 하 게 결정 있으며 A Double 내부적으로 최대 17 자리가 유지 되지만 값 최대 15 자리의 정밀도 사용 했습니다. 즉, 부동 소수점 연산 부동 변경 하려면 전체 자릿수를 없는 경우도 소수점 값입니다. 다음 예제에서 이에 대해 설명합니다. 매우 큰 부동 소수점 값을 정의 하 고 다음의 제품을 추가한 Double.Epsilon 를 1, 000 조 하 고 있습니다. 그러나 제품을이 너무 작아서 원래 부동 소수점 값을 수정 합니다. 최하위 자리는 1/1000, 제품의 최대 유효 자릿수 1은-312합니다.

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

제한 된 정밀도 부동 소수점 숫자의 몇 가지 결과가 발생 합니다.

  • 특정 전체 자릿수에 대 한 동일 하 게 나타나는 두 개의 부동 소수점 숫자 수 것으로 간주 최소 유효 자릿수가 다르기 때문에 있습니다. 다음 예제에서는 일련의 숫자를 더한 하 고 해당 합계의 예상 되는 전체와 비교 됩니다. 두 값이 동일한 것으로, 호출을 표시 하지만 Equals 메서드는 없다는 것을 나타냅니다.

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

    형식 항목을 변경 하는 경우는 Console.WriteLine(String, Object, Object) 에서 문을 {0}{1}{0:R}{1:R} 두 유효 자릿수를 모두 표시 하려면 Double 값이 명확한 경우 두 값 서로 같지 않은지 정밀도 손실 때문에 추가 작업 중입니다. 이 경우 호출 하 여 문제를 해결할 수 있습니다는 Math.Round(Double, Int32) 반올림 하는 메서드는 Double 비교를 수행 하기 전에 원하는 정밀도 값입니다.

  • 부동 소수점 숫자를 사용 하는 수치 또는 비교 연산을 하지 산출할 수 같은 결과 10 진수를 사용 하는 경우 이진 부동 소수점 숫자 10 진수 값과 같지 않을 때문에입니다. 앞의 예제. 1에서 10을 곱한 및.1 번 추가의 결과 표시 하 여이 나와 있습니다.

    소수 값으로 숫자 작업의 정확도 사용할 수 있습니다는 Decimal 보다는 Double 유형입니다. 때 숫자 정수 계열 값의 범위를 넘어 작업의 정확도 Int64 또는 UInt64 사용 하 여 형식을 반드시는 BigInteger 형식입니다.

  • 값에 부동 소수점 숫자가 포함 된 경우 라운드트립되지 않을 수 있습니다. 작업이 다른 폼에는 원래 부동 소수점 숫자를 변환 하 고 역 작업이 변환에서 변환 된 형식을 다시 부동 소수점 숫자, 최종 부동 소수점 숫자가 원래 부동 소수점 숫자와 같지 않습니다. 라운드트립 값 이라고 합니다. 하나 이상의 최소 유효 자릿수가 손실 되거나 변환에 대 한 변경의 왕복이 실패할 수 있습니다. 다음 예제에서 세 개의 Double 값을 문자열로 변환 되 고 파일에 저장 합니다. 그러나 출력 수 있듯이, 값이 동일 하 게 표시 하는 경우에 복원 된 값은 원래 값과 같지 않습니다.

    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
    

    이 경우 값은 성공적으로 라운드트립 사용 하 여 수 "R" 표준 숫자 형식 문자열 전체 자릿수를 유지 하기 위해 Double 다음 예제와 같이 값입니다.

    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:R}{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
    
  • Single 값 보다 적은 정밀도 Double 값입니다. A Single 겉보기에 해당 변환 된 값 Double 종종와 일치 하지 않음을 Double 값 정밀도에 차이가 있기 때문입니다. 다음 예제에서는 동일한 나누기 작업의 결과에 할당 됩니다는 DoubleSingle 값입니다. 이후에 Single 값으로 캐스팅 되는 Double, 두 값의 비교 같지 않은지를 보여 줍니다.

    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
    

    이 문제를 방지 하려면 하나를 사용에서 Double 대신는 Single 데이터 형식이 나 사용 하 여는 Round 메서드 두 값이 같은 정밀도 갖도록 합니다.

산술 및 할당 작업의 결과 또한 Double 값이 다른 약간 플랫폼에서의 전체 자릿수 손실이 발생 하므로 Double 유형입니다. 예를 들어, 리터럴 할당의 결과 Double 값 32 비트 및 64 비트 버전의.NET Framework에서 다를 수 있습니다. 다음 예제에서는이 때 그 차이 리터럴 값-4.42330604244772 e-305 및 변수 값이-4.42330604244772 e-305에 할당 되는 Double 변수입니다. 결과 Parse(String) 메서드가 경우 정밀도 손실에서 저하 되지 않습니다.

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      

같은, 두 개의 Double 값에 동일한 값을 나타내야 합니다. 그러나 정밀도 값 간의 차이 때문에 또는 하나 또는 두 값에 따라 정밀도 손실 때문에 종종 동일한 것으로 예상 되는 부동 소수점 값으로 판명 최하위 유효 자릿수에는 차이가 있으므로 동일 하지 않은 것입니다. 에 대 한 호출이 결과적으로,는 Equals 대 한 호출이 나 두 값이 같은지를 확인 하는 CompareTo 두 간의 관계를 확인할 수 있는 방법은 Double 값을 자주 예기치 않은 결과. 이 다음 예제에서 분명 한 두 개의 보이는 같아야 Double 첫 번째 두 번째 17에 있을 때 전체 자릿수는 15 자리에 있기 때문에 같지 않은 것으로 판명 된 값입니다.

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

계산 된 값을 서로 다른 코드 경로 따르는 및 다양 한 방법에서 종종 조작 되는 같지 않은 것으로 증명 합니다. 다음 예에서 한 Double 값을 제곱 하 고 원래 값으로 복원 하기 위해 제곱근 계산 되는 다음. 두 번째 Double 3.51으로 곱하고 원래 값으로 복원 3.51 나눈 결과의 제곱근 전에 제곱 됩니다. 두 값을 동일한 것으로 나타나지만에 대 한 호출에서 Equals(Double) 메서드 같지 않은지를 나타냅니다. 각 Double 값의 유효 자릿수를 모두 표시 하는 결과 문자열을 반환 하는 "R" 표준 형식 문자열을 사용 하 여 표시 된 두 번째 값.0000000000001 첫 번째 미만입니다.

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

정밀도 손실 비교의 결과 영향을 줄 가능성이 높은 경우에 호출 하 고 다음 대체 방법 중 하나 채택할 수 있습니다.는 Equals 또는 CompareTo 메서드:

  • 호출의 Math.Round 메서드 값이 모두 같은 정밀도 갖도록 합니다. 다음 예제에서는 두 개의 소수 값이 같으면 되도록이 방법을 사용 하는 이전 예제를 수정 합니다.

    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
    

    Note, 그러나 정밀도 문제 여전히 적용 된다는 중간점 값을 반올림 합니다. 자세한 내용은 Math.Round(Double, Int32, MidpointRounding) 메서드를 참조하세요.

  • 대략적인 같음 테스트를 일치 하는 대신 합니다. 절대 중 하나를 정의 하는이 위해서는 크기는 두 값 다를 수 있지만 여전히는 같아야 또는 더 작은 값 보다 큰 값에서 분기 수는 상대 크기를 정의 합니다.

    System_CAPS_warning경고

    Double.Epsilon 두 개의 디자이너 사이 거리의 절대 수단으로 사용 하는 경우도 Double 값이 같은지 여부를 테스트할 때. 그러나 Double.Epsilon 추가 하거나에서 뺀 수 있는 가장 작은 가능한 값을 측정 한 Double 값이 0 인 합니다. 대부분 양수 및 음수 Double 값, 값 Double.Epsilon 감지 너무 작습니다. 따라서 0 인 값을 제외 하 고 바람직하지 않습니다 같은지 테스트에 사용 합니다.

    다음 예제에서는 두 번째 방법을 사용 하 여 정의 IsApproximatelyEqual 두 값 간의 상대 차이 테스트 하는 메서드입니다. 에 대 한 호출의 결과 대비 되는 IsApproximatelyEqual 메서드 및 Equals(Double) 메서드.

    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
    

정수 계열 형식으로 0으로 나누기와 같은 잘못 된 작업 또는 오버플로 하는 경우에 예외를 throw, 작업과 달리 부동 소수점 값을 사용 하 여 작업 예외를 throw 하지 않습니다. 대신, 예외 상황 부동 소수점 작업의 결과 0, 양의 무한대, 음의 무한대 또는 (nan 숫자가) not-a-number 합니다.

  • 부동 소수점 작업의 결과가 대상 형식에 비해 너무 작은 경우 0이 됩니다. 다음 예제와 같이 두 매우 작은 숫자를 곱할 때 발생할 수 있습니다.

    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
    
  • 부동 소수점 작업의 결과의 크기가 대상 형식의 범위를 초과한 경우 작업의 결과 PositiveInfinity 또는 NegativeInfinity, 를 결과의 부호에 대 한 적절 하 게 합니다. 오버플로가 발생 하는 작업의 결과 Double.MaxValuePositiveInfinity, 및를 오버플로 하는 작업의 결과 Double.MinValueNegativeInfinity, 다음 예제와 같이 합니다.

    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
    

    PositiveInfinity 또한 긍정적인 피제수와 0으로 나누기에서 결과 및 NegativeInfinity 음수 피제수와 0으로 나누기의 결과입니다.

  • 부동 소수점 연산이 올바르지 않은 경우 작업의 결과 NaN합니다. 예를 들어 NaN 다음 작업에서 발생 합니다.

  • 부동 소수점 작업을 입력이 잘못 되었습니다. 예를 들어 호출는 Math.Sqrt 음수 값을 사용 하 여 메서드를 반환 NaN, 호출와 마찬가지로는 Math.Acos 메서드 값 보다 하나 이하의 보다 크면 음수 1을 사용 합니다.

  • 값이 인수가 지정 된 모든 작업 Double.NaN합니다.

Double 구조는 모든 명시적 또는 암시적 변환 연산자를 정의 하지 않습니다; 대신 변환 컴파일러에 의해 구현 됩니다.

모든 형식의 기본 숫자 값의 변환이 Double 확대 변환 하 고 따라서 있고이 명시적 캐스트 연산자는 컴파일러에서 명시적으로 필요한 경우가 아니면 변환 메서드를 호출 합니다. C# 컴파일러에서 변환에 대 한 캐스팅 연산자를 필요로 하는 예를 들어 DecimalDouble, Visual Basic 컴파일러는 손실 됩니다. 다음 예제에서는 다른 기본 숫자 형식의 최소값 또는 최대값 값 변환는 Double합니다.

using System;

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

또한는 SingleSingle.NaN, Single.PositiveInfinity, 및 Single.NegativeInfinity 를 몰래 Double.NaN, Double.PositiveInfinity, 및 Double.NegativeInfinity, 각각.

일부 숫자 형식의 값을 변환은 Double 값 정밀도 손실 될 수 있습니다. 변환할 때 정밀도 손실은 가능한 예제와 같이 Decimal, Int64, Single, 및 UInt64 값을 Double 값입니다.

변환 된 Double 다른 기본 숫자 데이터 형식의 값을는 축소 변환 하며 캐스트 연산자 (C#에서), (Visual Basic의 경우)의 변환 메서드 호출이 나는 Convert 메서드. 대상 유형으로 정의 되어 있는 대상 데이터 형식의 범위 밖에 있는 값 MinValueMaxValue 속성을 다음 표에 나와 있는 것 처럼 동작 합니다.

대상 유형

결과

모든 정수 계열 형식

OverflowException 확인 된 컨텍스트에서 변환이 발생 하는 경우는 예외입니다.

변환이 변환 작업이 성공 하지만 값이 오버플로되면 (C#의 기본값) 이면 unchecked 컨텍스트에서 발생 합니다.

Decimal

OverflowException 예외입니다.

Single

Single.NegativeInfinity 음수 값입니다.

Single.PositiveInfinity 양수 값입니다.

또한 Double.NaN, Double.PositiveInfinity, 및 Double.NegativeInfinity throw는 OverflowException 확인 된 컨텍스트에서 하지만 unchecked 컨텍스트에서 정수로 변환 하는 경우 이러한 값 오버플로 정수로 변환 합니다. 변환에 Decimal, 항상 발생 한 OverflowException합니다. 변환에 Single, 으로 변환 될 Single.NaN, Single.PositiveInfinity, 및 Single.NegativeInfinity, 각각.

변환에서 정밀도 손실이 발생할 수 있습니다는 참고를 Double 값을 다른 숫자 형식입니다. 비정 변환의 경우 Double 값 예의 출력에서 볼 수 있듯이 소수 부분이 손실 되는 경우는 Double 값은 반올림 됩니다 (예: Visual Basic) 또는 (예: C#) 잘립니다. 변환에 DecimalSingle 값은 Double 값 정확한 표시의 대상 데이터 형식을 가질 수 없습니다.

다음 예제에서는 다양 한 변환 Double 값을 다른 여러 가지 숫자 형식입니다. Visual Basic (기본값) 및 C#의 checked 컨텍스트에서 변환이 발생할 (때문에 체크 키워드)입니다. 예제의 출력에서 선택 된 변환에 대 한 결과 보여 줍니다. unchecked 컨텍스트. 으로 컴파일하여 Visual Basic의 unchecked 컨텍스트에서 변환을 수행할 수 있습니다는 /removeintchecks+ 컴파일러 스위치와 주석으로 처리 하 여 C#는 checked 문입니다.

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)

숫자 형식 변환에 대 한 자세한 내용은 참조 하십시오. .NET Framework의 형식 변환.NET Framework의 형식 변환표합니다.

Double 구조와 관련 된 형식을 다음과 같은 영역에서 작업을 수행 하는 메서드를 제공 합니다.

  • 값의 비교합니다. 호출할 수 있습니다는 Equals 두 지 여부를 결정 하는 메서드 Double 값이 같으면 또는 CompareTo 메서드를 두 값 간에 관계를 결정 합니다.

    Double 구조 또한 비교 연산자의 전체 집합을 지원 합니다. 예를 들어 같음 또는 같지 않음, 테스트 하거나 보다 크거나 같은 다른 하나의 값이 있는지 여부를 확인할 수 있습니다. 피연산자 중 하나는 숫자 이외의 형식인 경우는 Double, 변환할는 Double 비교를 수행 하기 전에 합니다.

    System_CAPS_warning경고

    전체 자릿수의 차이 때문에 두 개의 Double 동일한 것으로 예상 하는 값에 봉착할 같지 않은 것 비교 결과 영향을 미칩니다. 참조는 같음 테스트 두 개를 비교 하는 방법에 대 한 자세한 내용은 섹션 Double 값입니다.

    호출할 수도 있습니다는 IsNaN, IsInfinity, IsPositiveInfinity, 및 IsNegativeInfinity 를 이러한 특수 값에 대 한 테스트 합니다.

  • 수학 연산을합니다. 더하기, 빼기, 곱하기 및 나누기 등의 일반적인 산술 연산이 아니라 언어 컴파일러 및 공용 중간 언어 (CIL) 지침으로 구현 됩니다 Double 메서드. 수학 연산에서 피연산자 중 하나는 숫자 이외의 형식인 경우는 Double, 변환할는 Double 작업을 수행 하기 전에 합니다. 작업의 결과 이기도 한 Double 값입니다.

    호출 하 여 다른 수학 작업을 수행할 수 static (Shared Visual basic에서)의 메서드는 System.Math 클래스입니다. 일반적으로 산술 연산에 사용 되는 추가 메서드가 포함 됩니다 (같은 Math.Abs, Math.Sign, 및 Math.Sqrt), 기 하 도형 (와 같은 Math.CosMath.Sin), 및 계산법 (와 같은 Math.Log).

    개별 비트를 조작할 수 있습니다는 Double 값입니다. BitConverter.DoubleToInt64Bits 메서드 유지는 Double 값 비트 패턴을 64 비트 정수에의 합니다. BitConverter.GetBytes(Double) 메서드는 바이트 배열에 비트 패턴을 반환 합니다.

  • 반올림합니다. 반올림은 주로 사용 기술로 부동 소수점 표현 및 정밀도 문제로 인해 발생 하는 값 사이의 차이 따른 영향이 감소 됩니다. 반올림할 수는 Double 를 호출 하 여 값의 Math.Round 메서드.

  • 서식을합니다. 변환할 수는 Double 값을 호출 하 여 해당 문자열 표현에서 ToString 메서드 또는 합성 서식 지정 기능을 사용 하 여. 형식 문자열에서 부동 소수점 값의 문자열 표현을 제어 하는 방법에 대 한 내용은 참조는 표준 숫자 형식 문자열사용자 지정 숫자 형식 문자열 항목입니다.

  • 문자열 구문 분석합니다. 에 부동 소수점 값의 문자열 표현으로 변환할 수는 Double 호출 하 여 값의 Parse 또는 TryParse 메서드. 구문 분석 작업이 실패 하는 경우는 Parse 메서드가 예외를 throw 하는 반면는 TryParse 메서드 반환 false합니다.

  • 형식 변환합니다. Double 구조에 대 한 명시적 인터페이스 구현을 제공는 IConvertible 인터페이스를 두 표준.NET Framework 데이터 형식 간의 변환만 지원 합니다. 언어 컴파일러는 또한 다른 모든 표준 숫자 형식에 값의 암시적 변환이 지원 Double 값입니다. 표준 숫자 형식의 값으로 변환 된 Double 확대 변환 하 고 사용자에 캐스팅 연산자나 변환 메서드가 필요 하지 않습니다

    그러나 변환 Int64Single 값 정밀도 손실 될 수 있습니다. 다음 표에서 이러한 각 형식에 대 한 전체 자릿수의 차이 보여줍니다.

    형식

    최대 전체 자릿수

    내부 정밀도

    Double

    15

    17

    Int64

    19 10 진수

    19 10 진수

    Single

    10 진수 숫자 7

    9 10 진수

    전체 자릿수 문제에 영향을 가장 자주 Single 변환 된 값 Double 값입니다. 다음 예와에서 동일한 나누기 연산에 의해 발생 하는 두 개의 값 같지 않은 것 이므로 값 중 하나는 단 정밀도 부동 소수점 값으로 변환 된 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
    

다음 코드 예제에서는 Double:

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

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

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

		return m_value.ToString(format, provider);
	}

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

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

		return temp;
	}

	// The value holder
	protected double m_value;

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

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

Universal Windows Platform
4.5 이후에 사용 가능
.NET Framework
1.1 이후에 사용 가능
Portable Class Library
portable .NET platforms에서 지원 portable .NET platforms
Silverlight
2.0 이후에 사용 가능
Windows Phone Silverlight
7.0 이후에 사용 가능
Windows Phone
8.1 이후에 사용 가능

이 유형의 모든 멤버는 스레드로부터 안전 합니다. 인스턴스 상태를 수정 하려면 표시 되는 멤버는 실제로 새 값으로 초기화 하는 새 인스턴스를 반환 합니다. 으로 다른 종류와이 형식의 인스턴스를 포함 하는 공유 변수를 읽고 쓰는 보호 되어야 합니다 스레드로부터 안전을 보장 하려면 잠금에 의해.

System_CAPS_caution주의

이 형식의 인스턴스를 할당 하지 모든 하드웨어 플랫폼에서 스레드로부터 안전 수 없으므로 해당 인스턴스에서의 이진 표현 너무 커서 단일 원자성 작업에 할당 합니다.

맨 위로 이동
표시: