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

DateTime 구조체

 

게시 날짜: 2016년 11월

일반적으로 날짜와 시간으로 표시된 시간을 나타냅니다.

이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source합니다.

네임스페이스:   System
어셈블리:  mscorlib(mscorlib.dll에 있음)

[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, IConvertible, 
	ISerializable, IComparable<DateTime>, IEquatable<DateTime>

이름설명
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

DateTime 구조체의 새 인스턴스를 특정 연도, 월 및 날짜로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

DateTime 구조체의 새 인스턴스를 지정된 달력의 지정된 연도, 월 및 날짜로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32)

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 날짜, 시, 분 및 초로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

DateTime 구조체의 새 인스턴스를 지정된 달력에서 지정된 연도, 월, 일, 시, 분 및 초로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초 및 밀리초로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

DateTime 구조체의 새 인스턴스를 지정된 달력에서 지정된 연도, 월, 일, 시, 분, 초 및 밀리초로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

DateTime 구조체의 새 인스턴스를 지정된 달력의 지정된 연도, 월, 일, 시, 분, 초, 밀리초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초, 밀리초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.

System_CAPS_pubmethodDateTime(Int64)

DateTime 구조체의 새 인스턴스를 지정된 틱 수로 초기화합니다.

System_CAPS_pubmethodDateTime(Int64, DateTimeKind)

DateTime 구조체의 새 인스턴스를 지정된 틱 수 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.

이름설명
System_CAPS_pubpropertyDate

이 인스턴스의 날짜 구성 요소를 가져옵니다.

System_CAPS_pubpropertyDay

이 인스턴스가 나타내는 월의 일 수를 가져옵니다.

System_CAPS_pubpropertyDayOfWeek

이 인스턴스가 나타내는 요일을 가져옵니다.

System_CAPS_pubpropertyDayOfYear

이 인스턴스가 나타내는 일 수를 정수로 가져옵니다.

System_CAPS_pubpropertyHour

이 인스턴스가 나타내는 날짜의 시간 구성 요소를 가져옵니다.

System_CAPS_pubpropertyKind

이 인스턴스에 표시된 시간이 현지 시간 또는 UTC(협정 세계시)를 기준으로 하는지 아니면 둘 중 어느 것도 기준으로 하지 않는지를 나타내는 값을 가져옵니다.

System_CAPS_pubpropertyMillisecond

이 인스턴스가 나타내는 날짜의 밀리초 구성 요소를 가져옵니다.

System_CAPS_pubpropertyMinute

이 인스턴스가 나타내는 날짜의 분 구성 요소를 가져옵니다.

System_CAPS_pubpropertyMonth

이 인스턴스가 나타내는 날짜의 월 구성 요소를 가져옵니다.

System_CAPS_pubpropertySystem_CAPS_staticNow

이 컴퓨터의 현재 날짜와 시간으로 설정되고 현지 시간으로 표시되는 DateTime 개체를 가져옵니다.

System_CAPS_pubpropertySecond

이 인스턴스가 나타내는 날짜의 초 구성 요소를 가져옵니다.

System_CAPS_pubpropertyTicks

이 인스턴스의 날짜와 시간을 나타내는 틱 수를 가져옵니다.

System_CAPS_pubpropertyTimeOfDay

이 인스턴스에 대한 하루 중 시간을 가져옵니다.

System_CAPS_pubpropertySystem_CAPS_staticToday

현재 날짜를 가져옵니다.

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

이 컴퓨터의 현재 날짜와 시간으로 설정되고 UTC(협정 세계시)로 표시되는 DateTime 개체를 가져옵니다.

System_CAPS_pubpropertyYear

이 인스턴스가 나타내는 날짜의 연도 구성 요소를 가져옵니다.

이름설명
System_CAPS_pubmethodAdd(TimeSpan)

지정된 DateTime의 값을 이 인스턴스의 값에 더하는 새 TimeSpan을 반환합니다.

System_CAPS_pubmethodAddDays(Double)

지정된 날짜 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddHours(Double)

지정된 시간 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddMilliseconds(Double)

지정된 밀리초 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddMinutes(Double)

지정된 분 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddMonths(Int32)

지정된 월 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddSeconds(Double)

지정된 초 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddTicks(Int64)

지정된 틱 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodAddYears(Int32)

지정된 연도 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

DateTime의 두 인스턴스를 비교하고 첫 번째 인스턴스가 두 번째 인스턴스보다 빠른지, 같은지, 늦은지를 나타내는 정수를 반환합니다.

System_CAPS_pubmethodCompareTo(DateTime)

이 인스턴스의 값을 지정된 DateTime 값과 비교하고 이 인스턴스가 지정된 DateTime 값보다 이전인지, 같은지 또는 이후인지를 나타내는 정수를 반환합니다.

System_CAPS_pubmethodCompareTo(Object)

이 인스턴스의 값을 지정된 DateTime 값이 포함된 지정된 개체와 비교하고, 이 인스턴스가 지정된 DateTime 값보다 이전인지, 같은지 또는 이후인지를 나타내는 정수를 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

지정된 월과 연도의 날짜 수를 반환합니다.

System_CAPS_pubmethodEquals(DateTime)

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

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

DateTime 인스턴스의 날짜 및 시간 값이 같은지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodEquals(Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

64비트 이진 값을 deserialize하고 serialize된 원본 DateTime 개체를 다시 만듭니다.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

지정한 Windows 파일 시간을 해당 현지 시간으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

지정한 Windows 파일 시간을 해당 UTC 시간으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

지정된 OLE 자동화 날짜에 해당하는 DateTime을 반환합니다.

System_CAPS_pubmethodGetDateTimeFormats()

이 인스턴스의 값을 표준 날짜 및 시간 서식 지정자에서 지원하는 모든 문자열 표현으로 변환합니다.

System_CAPS_pubmethodGetDateTimeFormats(Char)

이 인스턴스의 값을 지정된 표준 날짜 및 시간 서식 지정자에서 지원하는 모든 문자열 표현으로 변환합니다.

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

이 인스턴스의 값을 지정된 표준 날짜 및 시간 서식 지정자와 문화권별 서식 지정 정보에서 지원하는 모든 문자열 표현으로 변환합니다.

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

이 인스턴스의 값을 표준 날짜 및 시간 서식 지정자와 지정된 문화권별 서식 지정 정보에서 지원하는 모든 문자열 표현으로 변환합니다.

System_CAPS_pubmethodGetHashCode()

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

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodGetTypeCode()

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

System_CAPS_pubmethodIsDaylightSavingTime()

DateTime의 이 인스턴스가 현재 시간대의 일광 절약 시간 범위 내에 있는지를 나타냅니다.

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

지정된 연도가 윤년인지를 나타내는 표시를 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

날짜 및 시간에 대한 문자열 표현을 해당 DateTime으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

문화권별 형식 정보를 사용하여 날짜 및 시간의 문자열 표현을 해당 DateTime으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 문자열 표현을 해당 DateTime으로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider, DateTimeStyles)

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다. 문자열 표현의 서식은 지정된 서식과 정확하게 일치해야 합니다. 그렇지 않으면 예외가 throw됩니다.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String[], IFormatProvider, DateTimeStyles)

지정된 형식 배열, 문화권별 형식 정보 및 스타일을 사용하여 지정된 날짜와 시간의 문자열 표현을 해당 DateTime 표현으로 변환합니다. 문자열 표현의 서식은 지정된 형식 중 최소한 하나와 정확하게 일치해야 합니다. 그렇지 않으면 예외가 throw됩니다.

System_CAPS_pubmethodSystem_CAPS_staticSpecifyKind(DateTime, DateTimeKind)

지정된 DateTime과 틱 수가 같지만 지정된 DateTime 값이 나타내듯이 현지 시간 또는 UTC(협정 세계시)로 지정되거나 둘 중 어느 것으로도 지정되지 않은 새 DateTimeKind 개체를 만듭니다.

System_CAPS_pubmethodSubtract(DateTime)

이 인스턴스에서 지정된 날짜와 시간을 뺍니다.

System_CAPS_pubmethodSubtract(TimeSpan)

지정된 기간을 이 인스턴스에서 뺍니다.

System_CAPS_pubmethodToBinary()

현재 DateTime 개체를 나중에 DateTime 개체를 다시 만드는 데 사용할 수 있는 64비트 이진 값으로 serialize합니다.

System_CAPS_pubmethodToFileTime()

현재 DateTime 개체의 값을 Windows 파일 시간으로 변환합니다.

System_CAPS_pubmethodToFileTimeUtc()

현재 DateTime 개체의 값을 Windows 파일 시간으로 변환합니다.

System_CAPS_pubmethodToLocalTime()

현재 DateTime 개체의 값을 현지 시간으로 변환합니다.

System_CAPS_pubmethodToLongDateString()

현재 DateTime 개체의 값을 해당하는 긴 날짜 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToLongTimeString()

현재 DateTime 개체의 값을 해당하는 긴 시간 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToOADate()

이 인스턴스의 값을 해당 OLE 자동화 날짜로 변환합니다.

System_CAPS_pubmethodToShortDateString()

현재 DateTime 개체의 값을 해당하는 짧은 날짜 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToShortTimeString()

현재 DateTime 개체의 값을 해당하는 짧은 시간 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToString()

현재 문화권의 형식 규칙을 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.(ValueType.ToString()을(를) 재정의함)

System_CAPS_pubmethodToString(IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToString(String)

현재 문화권의 형식 규칙과 지정된 형식을 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToString(String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 현재 DateTime 개체의 값을 해당 문자열 표현으로 변환합니다.

System_CAPS_pubmethodToUniversalTime()

현재 DateTime 개체의 값을 UTC(협정 세계시)로 변환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, DateTime)

날짜와 시간에 대한 지정된 문자열 표현을 해당 DateTime 요소로 변환하고, 변환에 성공했는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, IFormatProvider, DateTimeStyles, DateTime)

지정된 문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환하고 변환에 성공했는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다. 이 메서드는 변환이 성공했는지 아니면 실패했는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

지정된 형식 배열, 문화권별 형식 정보 및 스타일을 사용하여 지정된 날짜와 시간의 문자열 표현을 해당 DateTime 표현으로 변환합니다. 문자열 표현 형식은 지정된 형식과 정확히 일치해야 합니다. 이 메서드는 변환이 성공했는지 아니면 실패했는지를 나타내는 값을 반환합니다.

이름설명
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

DateTime의 최대값을 나타냅니다. 이 필드는 읽기 전용입니다.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

DateTime의 최소값을 나타냅니다. 이 필드는 읽기 전용입니다.

이름설명
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

지정된 시간 간격을 지정된 날짜 및 시간에 더하여 새로운 날짜와 시간을 얻습니다.

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

DateTime의 지정된 두 인스턴스가 같은지를 확인합니다.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

지정된 DateTime이 지정된 다른 DateTime보다 나중인지를 판단합니다.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

지정된 DateTime이 다른 지정된 DateTime과 같거나 나중인 날짜와 시간을 나타내는지를 결정합니다.

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

DateTime의 지정된 두 인스턴스가 다른지를 확인합니다.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

지정된 DateTime이 지정된 다른 DateTime보다 이전인지를 판단합니다.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

지정된 DateTime이 다른 지정된 DateTime과 같거나 이전인 날짜와 시간을 나타내는지를 결정합니다.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

지정된 날짜와 시간을 지정된 다른 날짜와 시간에서 빼고 시간 간격을 반환합니다.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

지정된 날짜와 시간에서 지정된 시간 간격을 빼고 새 날짜와 시간을 반환합니다.

이름설명
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

이 API는 제품 인프라를 지원하며 코드에서 직접 사용할 수 없습니다. 현재 DateTime 개체를 반환합니다.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

이 API는 제품 인프라를 지원하며 코드에서 직접 사용할 수 없습니다. 현재 DateTime 개체를 지정된 형식의 개체로 변환합니다.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

현재 SerializationInfo 개체를 serialize하는 데 필요한 데이터로 DateTime 개체를 채웁니다.

System_CAPS_note참고

이 형식에 대 한.NET Framework 소스 코드를 보려면 참조는 Reference Source합니다. 소스 코드를 온라인, 오프 라인에서 살펴보고에 대 한 참조를 다운로드 및; 디버그 시 소스 (패치 및 업데이트 포함)를 단계별로 실행 see instructions.

DateTime 값 형식 사이의 값이 00시: 00 (자정) 년 1 월 1 일에서 0001 서 기 (Common Era) 오후 11시 59분: 59를 통해 서 기 9999 년 12 월 31 일 (협정 세계시) 에 해당 합니다.

시간 값 틱 이라는 100 나노초 단위로 측정 되 고 특정 날짜는 서 기 0001 년 1 월 1 일 자정 12 시 이후 틱 수는 (협정 세계시) 에 GregorianCalendar 달력 (윤 초에 의해 추가 틱 제외). 예를 들어 31241376000000000l 틱 값 0100 년 1 월 1 일, 금요일 12시: 00 자정 날짜를 나타냅니다. A DateTime 값은 항상 명시적의 컨텍스트 또는 기본 달력으로 표현 됩니다.

System_CAPS_note참고

사용 하는 눈금 값을 변환할 분 또는 초 같은 일부 다른 시간 간격을 사용 해야 하는 경우는 TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, 또는 TimeSpan.TicksPerMillisecond 변환을 수행 하는 상수입니다. 예를 들어 시간 (초) 수를 추가 하려면 틱의 지정된 된 수로 표현 된 Second 의 구성 요소는 DateTime 값을는 식을 사용할 수 있습니다 dateValue.Second + nTicks/Timespan.TicksPerSecond합니다.

섹션 내용

DateTime 개체 인스턴스화
DateTime 값과 해당 문자열 표현
문자열을 DateTime 값으로 변환
버전 고려 사항
날짜/시간 값
날짜/시간 작업
날짜/시간 확인
날짜/시간 vs입니다. TimeSpan
날짜/시간 값 및 달력
날짜/시간 값 유지
COM interop 고려 사항

새를 만들 수 있습니다 DateTime 다음 방법 중 하나는 값:

  • 오버 로드 중 하나를 호출 하 여는 DateTime 날짜 및 시간 값 (예: 년, 월 및 일, 또는 틱 수)의 특정 요소를 지정할 수 있도록 하는 생성자입니다. 다음 문에서 중 하나에 대 한 호출을 보여 줍니다.는 DateTime 특정 연도, 월, 일, 시간, 분 및 초를 사용 하 여 날짜를 만들려면 생성자입니다.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • 날짜 및 시간 값을 선언 하기 위한 모든 관련 컴파일러 구문을 사용 합니다. 예를 들어 다음 Visual Basic 문은 새를 초기화 DateTime 값입니다.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • 할당 하 여는 DateTime 개체 속성 또는 메서드에서 반환 된 날짜 및 시간 값입니다. 다음 예제에서는 현재 날짜 및 시간, 현재 utc (협정 세계시) 날짜 및 시간 및 현재 날짜를 할당 3 개의 새 DateTime 변수입니다.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • 날짜 및 시간 값의 문자열 표현을 구문 분석 합니다. Parse, ParseExact, TryParse, 및 TryParseExact 메서드는 모두 문자열 해당 날짜 및 시간 값을 변환 합니다. 다음 예제에서는 Parse 문자열 구문 분석 및 변환 메서드는 DateTime 값입니다.

    string dateString = "5/1/2008 8:30:52 AM";
    DateTime date1 = DateTime.Parse(dateString, 
                              System.Globalization.CultureInfo.InvariantCulture); 
    

    TryParseTryParseExact 메서드는 특정 문자열의 유효한 표현이 포함 되는지 여부를 나타내는 DateTime 변환을 수행 하는 것 외에도 값입니다.

  • 호출 하 여는 DateTime 구조체의 암시적 기본 생성자입니다. (암시적 기본 생성자는 값 형식에 대 한 세부 정보를 참조 하십시오. 값 형식(C# 참조).) 지원 되는 컴파일러에 대 한 대략적인 해당 선언는 DateTime 값을 날짜와 시간을 명시적으로 할당 하지 않고 있습니다. 다음 예제에 대 한 호출에서 DateTime C# 및 Visual Basic에서 암시적 기본 생성자와 함께 DateTime 없는 할당이 Visual Basic의 변수 선언 합니다.

    DateTime dat1 = new DateTime();
    // The following method call displays 1/1/0001 12:00:00 AM.
    Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
    // The following method call displays True.
    Console.WriteLine(dat1.Equals(DateTime.MinValue));
    

내부적으로, 모든 DateTime 값 (100 나노초 간격의 수) 0001 년 1 월 1 일 12시: 00 자정 이후 경과 된 틱 수로 표현 됩니다. 실제 DateTime 값은 해당 값이 파일에 기록 하는 경우 또는 사용자 인터페이스 요소에 표시 될 때 표시 되는 방식에 독립적입니다. 모양을 DateTime 서식 지정 작업의 결과 값입니다. 서식이 값을 문자열 표현으로 변환 됩니다.

날짜 및 시간 값의 모양을 문화권, 국제 표준, 응용 프로그램 요구 사항 및 개인 기본 설정 같은 요소에 종속 되어 있으므로 DateTime 다양 한 오버 로드를 통해 날짜 및 시간 값 서식 지정에 유연성을 제공 하는 구조는 ToString 메서드. 기본 DateTime.ToString() 메서드는 현재 문화권의 간단한 날짜 및 자세한 시간 패턴을 사용 하 여 날짜 및 시간 값의 문자열 표현을 반환 합니다. 다음 예제에서는 기본 DateTime.ToString() 문화권 및 간단한 날짜 및 자세한 시간 패턴을 사용 하 여 EN-US에 대 한 시간을 날짜를 표시 하는 메서드를 사용 하면 예제를 실행 하는 컴퓨터의 현재 문화권입니다.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM

DateTime.ToString(IFormatProvider) 메서드는 간단한 날짜와 특정 문화권의 긴 시간 패턴을 사용 하 여 날짜 및 시간 값의 문자열 표현을 반환 합니다. 다음 예제에서는 DateTime.ToString(IFormatProvider) 메서드 및 FR-FR 문화권에 대 한 간단한 날짜 및 자세한 시간 패턴을 사용 하 여 시간을 날짜를 표시 합니다.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00

DateTime.ToString(String) 메서드가 현재 문화권의 서식 지정 규칙을 사용 하 여 표준 또는 사용자 지정 형식 지정자에 의해 정의 된 형식으로 날짜 및 시간의 문자열 표현을 반환 합니다. 다음 예제에서는 DateTime.ToString(String) 문화권 전체 날짜 및 시간 패턴 EN-US을 표시 하는 메서드를 사용 하면 예제를 실행 하는 컴퓨터의 현재 문화권입니다.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM

DateTime.ToString(String, IFormatProvider) 메서드는 특정 문화권의 서식 지정 규칙을 사용 하는 특정 형식 지정자에 정의 된 형식으로 날짜 및 시간의 문자열 표현을 반환 합니다. 다음 예제에서는 DateTime.ToString(String, IFormatProvider) 메서드를 전체 날짜 및 시간 패턴 FR-FR 문화권을 표시 합니다.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00

서식 지정 하는 방법에 대 한 자세한 내용은 DateTime 값, 참조 표준 날짜 및 시간 형식 문자열사용자 지정 날짜 및 시간 형식 문자열합니다.

구문 분석의 날짜와 시간의 문자열 표현으로 변환 하는 DateTime 값입니다. 일반적으로 날짜 및 시간 문자열 응용 프로그램에서 두 개의 서로 다른 용도가지고 있습니다.

  • 날짜 및 시간이 현재 문화권 또는 특정 문화권의 규칙을 반영 하 고 다양 한 형태를 가져올 수 있는 나타냅니다. 예를 들어 응용 프로그램 현재 문화권이 EN-US "12/15/2013" 또는 "2013 년 12 월 15 일"로 날짜 값을 입력에 사용자 및 사용자가 현재 문화권이 EN-GB "2013-15-12" 또는 "2013 15 년 12 월"로 날짜 값을 입력 합니다.

  • 날짜 및 시간을 미리 정의 된 형식에 나타냅니다. 예를 들어 응용 프로그램와 독립적으로 문화권을 앱을 실행 하거나 현재 문화권의 간단한 날짜 형식으로 날짜를 입력할 수 필요할 수 있습니다 "20130103"로 날짜를 직렬화 할 수 있습니다.

사용할 수는 Parse 또는 TryParse 수 문화권을 사용 하는 일반적인 날짜 및 시간 형식 중 하나를 반영 하는 문자열을 변환 하는 메서드는 DateTime 값입니다. 다음 예제에서는 사용 하는 방법을 보여 줍니다. TryParse 다양 한 다른 문화권별 형식으로 날짜 문자열을 변환 하는 DateTime 값입니다. 현재 문화권이 영어 (영국) 및 호출 변경는 GetDateTimeFormats() 날짜 및 시간 문자열의 배열을 생성 하는 메서드. 그런 다음 배열의 각 요소에 전달 된 TryParse 메서드. 이 예제에서 출력 변환할 성공적으로 각 문화권별 날짜 및 시간 문자열 구문 분석 방법 못했음을 보여 줍니다.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      DateTime date1 = new DateTime(2013, 6, 1, 12, 32, 30);
      List<string> badFormats = new List<String>();

      Console.WriteLine("{0,-37} {1,-19}\n", "Date String", "Date");
      foreach (var dateString in date1.GetDateTimeFormats()) {
         DateTime parsedDate;
         if (DateTime.TryParse(dateString, out parsedDate))
            Console.WriteLine("{0,-37} {1,-19}", dateString, DateTime.Parse(dateString));
         else
            badFormats.Add(dateString);
      } 

      // Display strings that could not be parsed.
      if (badFormats.Count > 0) {
         Console.WriteLine("\nStrings that could not be parsed: ");
         foreach (var badFormat in badFormats)
            Console.WriteLine("   {0}", badFormat);         
      }
   }
}
// The example displays the following output:
//       Date String                           Date               
//       
//       01/06/2013                            01/06/2013 00:00:00
//       01/06/13                              01/06/2013 00:00:00
//       1/6/13                                01/06/2013 00:00:00
//       1.6.13                                01/06/2013 00:00:00
//       2013-06-01                            01/06/2013 00:00:00
//       01 June 2013                          01/06/2013 00:00:00
//       1 June 2013                           01/06/2013 00:00:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       01 June                               01/06/2013 00:00:00
//       01 June                               01/06/2013 00:00:00
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       2013-06-01T12:32:30                   01/06/2013 12:32:30
//       12:32                                 22/04/2013 12:32:00
//       12:32                                 22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
//       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
//       June 2013                             01/06/2013 00:00:00
//       June 2013                             01/06/2013 00:00:00

사용할 수는 TryParseTryParseExact 특정 형식 또는 형식으로 일치 해야 하는 날짜 및 시간 문자열을 변환 하는 메서드는 DateTime 값입니다. 하나 이상의 구문 분석 methodby 사용 하거나 날짜 및 시간 형식 문자열에 매개 변수로 필요한 형식 또는 형식 지정합니다. 다음 예제에서는 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) "yyyyMMdd" 형식 또는 "HHmmss" 형식으로 지정 해야 하는 문자열을 변환 하는 메서드 DateTime 값입니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats = { "yyyyMMdd", "HHmmss" };
      string[] dateStrings = { "20130816", "20131608", "  20130816   ", 
                               "115216", "521116", "  115216  " };
      DateTime parsedDate;

      foreach (var dateString in dateStrings) {
         if (DateTime.TryParseExact(dateString, formats, null, 
                                    DateTimeStyles.AllowWhiteSpaces |
                                    DateTimeStyles.AdjustToUniversal,
                                    out parsedDate))
            Console.WriteLine("{0} --> {1:g}", dateString, parsedDate);
         else
            Console.WriteLine("Cannot convert {0}", dateString);
      }
   }
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

ParseParseExact 메서드 예외를 throw 하는 경우 문자열을 변환할 수는 DateTime 값을 구문 분석할 수 없습니다. TryParseTryParseExact 메서드 반환는 Boolean 변환이 성공 했는지 아니면 실패 했는지를 나타내는 값입니다. 날짜 및 시간 문자열에 대 한 구문 분석 작업 문자열은 사용자가 입력 하는 경우에 특히, 포함 하려는 경향이 높은 실패율 및 예외 처리 비용이 많이 드는 이기 때문에 사용 해야 하기 때문에 TryParse 또는 TryParseExact 성능이 중요 한이 하거나 변환에는 오류 비율이 적용 시나리오에서 메서드.

날짜 및 시간 값을 구문 분석 하는 방법에 대 한 자세한 내용은 참조 .NET Framework의 날짜 및 시간 문자열 구문 분석합니다.

.NET Framework 버전 2.0, 하기 전에 DateTime 개인과 연결 하는 사용 하지 않는 2 비트 필드는 구성 하는 64 비트 필드를 포함 하는 구조 Ticks 는 날짜와 시간을 나타내는 틱 수를 포함 하는 부호 없는 62 비트 필드는 필드를 합니다. 값은 Ticks 필드를 통해 얻을 수는 Ticks 속성입니다.

.NET Framework 2.0 부터는 DateTime 틱 필드와 연결 된 개인 Kind 필드를 구성 하는 64 비트 필드를 포함 하는 구조입니다. Kind 필드는 나타내는 2 비트 필드 여부는 DateTime 구조체 현지 시간을 Utc (협정 세계시), 또는 지정 되지 않은 표준 시간대의 시간을 나타냅니다. Kind 필드/시간 비교 또는 산술 하지만 표준 시간대 간에 시간 변환 수행할 때 사용 됩니다. Kind 필드의 값을 가져올 수 있습니다는 Kind 속성입니다.

System_CAPS_note참고

하는 대신은 DateTime 은 특히 시간대 날짜 및 시간 값 작업에 대 한 구조는 DateTimeOffset 구조입니다. DateTimeOffset private에 날짜 및 시간 정보를 저장 하는 구조 DateTime 필드 및 기준인 해당 날짜와 시간을 분 단위로 서로 다른 측정 된 UTC에서 개인 Int16 필드입니다. 그러면 수에 대 한는 DateTimeOffset 반면 특정 표준 시간대의 시간을 반영 하도록 값을 DateTime 만 UTC와 현지 표준 시간대의 시간 값 반영 명확 하 게 될 수 있습니다. 사용 하는 경우에 대 한 토론에 대 한는 DateTime 구조 또는 DateTimeOffset 날짜 및 시간 값을 작업할 때 구조을 참조 DateTime, DateTimeOffset, TimeSpan 및 TimeZoneInfo 중 선택합니다.

시간 값에 대 한 설명은 DateTime 형식 이름인 국제 승인 그리니치 표준시 (GMT)에 대 한 utc (협정 세계시) 표준을 사용 하 여 표현 종종 됩니다. UTC 시작 지점 경도 0도에서 측정 되는 시간입니다. 일광 절약 시간을 UTC 적용 되지 않습니다.

현지 시간 특정 표준 시간대에 상대적입니다. 표준 시간대를 UTC 시작 지점부터 시간 단위로 측정 된 표준 시간대의 이동을 나타내는 표준 시간대 오프셋을 연관 되어 있습니다. 또한 현지 시간을 추가 하거나 하루 길이에서 한 시간을 추출 하는 일광 절약 시간을 필요에 따라 달라 집니다. 따라서 현지 시간 UTC와 필요한 경우 일광 절약 시간제에 맞게 조정에 표준 시간대 오프셋을 추가 하 여 계산 됩니다. UTC 시작 지점에서 표준 시간대 오프셋은 0입니다.

UTC 시간 중인 파일의 경우 계산, 비교 및 저장할 날짜 및 시간에 적합 합니다. 현지 시간은 데스크톱 응용 프로그램의 사용자 인터페이스에 표시 하기에 적합 합니다. 표준 시간대 인식 응용 프로그램 (예: 여러 웹 응용 프로그램)도 다양 한 다른 표준 시간대와 작동 해야 합니다.

경우는 Kind 속성은 DateTime 개체가 DateTimeKind.Unspecified, 표시 된 시간이 현지 시간 또는 UTC 시간, 일부 다른 표준 시간대의 시간 인지 지정 되지 않습니다.

사용 하 여 계산 된 DateTime 구조체와 같은 Add 또는 Subtract, 구조체의 값을 수정 하지 않습니다. 대신 계산 반환 새 DateTime 구조 값은 계산의 결과입니다.

표준 시간대 (예: UTC와 현지 시간 또는 한 표준 시간대와 다른) 간의 변환 작업의 계정으로 일광 절약 시간제 걸리지만 산술 및 비교 연산은 그렇지 않습니다.

DateTime 구조 자체 한 표준 시간대에서 다른 형식으로 변환 하는 것에 대 한 제한 된 지원을 제공 합니다. 사용할 수는 ToLocalTime 사용 하 여 메서드를 현지 시간을 UTC 형식으로 변환할 수는 ToUniversalTime 현지 시간에서 UTC로 변환 하는 메서드입니다. 그러나 표준 시간대 변환 메서드의 전체 집합은 영어로 TimeZoneInfo 클래스입니다. 이러한 메서드를 사용 하 여 다른 표준 시간대의 시간 중 하나라도 세계에서 표준 시간대의에서 시간을 변환할 수 있습니다.

계산 하 고 비교 DateTime 개체는 개체가 동일한 표준 시간대의 시간을 나타내는 경우에 의미를 갖습니다. 사용할 수는 TimeZoneInfo 나타내는 개체를 한 DateTime 값의 시간 영역을 두는 느슨하게 결합 되어 있지만 합니다. (즉, DateTime 이외의 해당 날짜 및 시간 값의 표준 시간대를 나타내는 개체를 반환 하는 속성 개체에 없는 Kind 속성입니다.) 표준 시간대를 확인 하려면 외부 메커니즘에 의존 해야 표준 시간대 인식 응용 프로그램에서는 이러한 이유로 DateTime 개체가 생성 되었습니다. 예를 들어 둘 다를 래핑하는 구조체를 사용할 수 있습니다는 DateTime 값 및 TimeZoneInfo 을 나타내는 개체는 DateTime 값의 표준 시간대입니다. UTC를 사용 하 여 계산 및 비교에 대 한 자세한 내용은 DateTime 값, 참조 날짜 및 시간에 대한 산술 연산 수행합니다.

DateTime 달력을 지정 하는 생성자를 제외 하 고 해당 작업을 수행 구성원 암시적으로 사용 하 여 일반 달력에서 파생 된 매개 변수가 있는 메서드 및 IFormatProvider와 같은 System.Globalization.DateTimeFormatInfo, 암시적으로 일정을 지정 하는 합니다.

작업의 멤버는 DateTime 형식 윤년 및 달의 일 수와 같은 정보를 고려 합니다.

다른 두 개의 일반적인 작업을 DateTime 값 포함 하거나 해당 문자열 표현에서 날짜 및 시간 값으로 변환 합니다. 변환 프로세스는 DateTime 값 문자열 표현으로 서식 지정 작업은; 형식에 대 한 자세한 내용은 참조 날짜/시간 값과 해당 문자열 표현합니다. 날짜와 시간의 문자열 표현을 변환 프로세스는 DateTime 값은 구문 분석 작업; 구문 분석 하는 방법에 대 한 자세한 내용은 참조 문자열을 DateTime 값으로 변환합니다.

System_CAPS_note참고

날짜 및 시간 산술 연산을 수행 하는 대신 DateTime 값 경과 시간 측정을 사용할 수 있습니다는 Stopwatch 클래스입니다.

Ticks 속성 초, 1 천만 단위로 날짜 및 시간 값 표현 및 Millisecond 속성 초의 1/1000 날짜 및 시간 값을 반환 합니다. 그러나 반복 된 호출을 사용 하는 경우는 DateTime.Now 속성을 경과 된 시간을 측정 하 고 100 밀리초 미만인 작은 시간 간격을 유지 하려는, 의해 반환 된 값에 유의 해야 합니다는 DateTime.Now 속성 약 15 밀리초 해상도 Windows 8 및 Windows 7 시스템에는 시스템 클록에 따라 달라 집니다.

다음 예제에서는 현재 날짜 및 시간 값의 시스템 클록의 해상도에 대 한 종속성을 보여 줍니다. 예제에서는 외부 루프를 20 회 반복 및 내부 루프 외부 루프를 지연 하는 데 사용 합니다. 외부 루프 카운터의 값은 10이 고에 대 한 호출 하는 경우는 Thread.Sleep 메서드 5 밀리초 지연을 소개 합니다. 시간을 밀리초 단위로 반환한 예제의 출력에서 볼 수 있듯이 DateTime.Now.Milliseconds 속성에 대 한 호출 후에 변경 Thread.Sleep합니다.

using System;
using System.Threading;

public class Example
{
   public static void Main()
   {
      String output = "";
      for (int ctr = 0; ctr <= 20; ctr++) {
         output += String.Format("{0}\n", DateTime.Now.Millisecond);
         // Introduce a delay loop.
         for (int delay = 0; delay <= 1000; delay++)
         {}

         if (ctr == 10) {
            output += "Thread.Sleep called...\n";
            Thread.Sleep(5);
         }
      }
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       Thread.Sleep called...
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143

DateTimeTimeSpan 값 형식 한다는 점에서 차이가 DateTime 시간에서 인스턴트를 나타내는 반면는 TimeSpan 시간 간격을 나타냅니다. 즉, 예를 들어 하나의 인스턴스만 뺄 수도 DateTime 에서 다른를 가져올는 TimeSpan 사이의 시간 간격을 나타내는 개체입니다. 또는 양수를 추가할 수 있습니다 TimeSpan 현재 DateTime 얻으려고는 DateTime 날짜는 미래의 날짜를 나타내는 값입니다.

추가 하거나에서 시간 간격을 뺄 수 있습니다는 DateTime 개체입니다. 양수 또는 음수일 수 있습니다, 틱 또는 초 단위 표현할 수 있습니다 또는으로 표현할 수 있는 시간 간격을 TimeSpan 개체입니다.

.NET Framework 클래스 라이브러리는 다양 한 달력 클래스에서 파생 되는 모두 포함 된 Calendar 클래스입니다. 다음 창이 여기에 포함됩니다.

해당 읽기 전용으로 정의 하는 기본 달력을 사용 하 여 각 문화권 CultureInfo.Calendar 속성과 해당 읽기 전용으로 정의 된 하나 이상의 일정 지원 CultureInfo.OptionalCalendars 속성입니다. 현재 사용 하는 특정 달력 CultureInfo 개체도 정의 됩니다 해당 DateTimeFormatInfo.Calendar 속성에는 달력 중 하나 여야 합니다는 CultureInfo.OptionalCalendars 배열입니다.

문화권의 현재 달력은 해당 문화권에 대 한 모든 형식 지정 작업에 사용 됩니다. 예를 들어 기본 페르시아어 (이란) 문화권의 달력이 um 쿠라 달력으로 표현 되는 UmAlQuraCalendar 클래스입니다. 때는 CultureInfo 페르시아어 (이란) 문화권을 나타내는 날짜 및 시간 형식 작업에 사용 됩니다는 쿠라 달력 기본적으로 사용 되는 um 고 경우에 사용 하는 일반 달력 문화권의 DateTimeFormatInfo.Calendar 다음 예제와 같이 속성을 변경 합니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = new DateTime(2016, 5, 28);

      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
// 08/03/1395 12:00:00 ?.?
// 28/05/2016 12:00:00 ?.?

문화권의 현재 달력은 다음 예제와 같이 해당 culture에 대 한 모든 구문 분석 작업에도 사용 됩니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = DateTime.Parse("08/03/1395", faIR);
      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
//       08/03/1395 12:00:00 ?.?
//       28/05/2016 12:00:00 ?.?

인스턴스화할 수 있습니다는 DateTime 호출 하 여 특정 달력 날짜 및 시간 요소 (예: 년, 월 및 일 수)를 사용 하 여 값은 DateTime 생성자 포함 하는 calendar 매개 변수 전달 하는 Calendar 그 달력을 나타내는 개체입니다. 다음 예제에서는 날짜 및 시간 요소를 사용 하 여는 UmAlQuraCalendar 달력.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var dat = new DateTime(1395, 8, 18, faIR.DateTimeFormat.Calendar);
      Console.WriteLine("Umm-al-Qura date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Gregorian date:   {0:d}", dat);
   }
}
// The example displays the following output:
//       Umm-al-Qura date: 18/08/1395
//       Gregorian date:   11/8/2016

DateTime포함 하지 않는 생성자는 calendar 매개 변수 가정 날짜 및 시간 요소는 일반 달력의 단위로 표현 됩니다.

다른 모든 DateTime 속성 및 메서드는 일반 달력을 사용 합니다. 예를 들어는 DateTime.Year 일반 달력의 연도 반환 하는 속성 및 DateTime.IsLeapYear(Int32) 메서드 가정 하는 year 매개 변수는 일반 달력의 연도입니다.DateTime 일반 달력을 사용 하 여 멤버의 해당 멤버가 Calendar 특정 달력을 사용 하는 클래스입니다. 예를 들어는 Calendar.GetYear 특정 달력의 연도 반환 하는 메서드 및 Calendar.IsLeapYear 1 보다 크거나는 year 특정 달력의 연도 수로 매개 변수입니다. 다음 예제에서는 사용 하 여 둘 다는 DateTime 및 해당 멤버의는 UmAlQuraCalendar 클래스입니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var cal = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, cal);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Year: {0}", cal.GetYear(dat));
      Console.WriteLine("Leap year: {0}\n", 
                        cal.IsLeapYear(cal.GetYear(dat)));

      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Year: {0}", dat.Year);
      Console.WriteLine("Leap year: {0}", DateTime.IsLeapYear(dat.Year));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Year: 1395
//       Leap year: True
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Year: 2016
//       Leap year: True

하지만 DateTime 구조에 포함 되어 DayOfWeek 일반 달력의 주의 일을 반환 하는 속성을 포함 하지 않으므로 해당 연도의 주 번호를 검색할 수 있는 멤버입니다. 해당 연도의 주를 검색 하려면 개별 달력의 호출 Calendar.GetWeekOfYear 메서드. 다음 예제에서 이에 대해 설명합니다.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var umAlQura = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, umAlQura);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Day of Week: {0}", umAlQura.GetDayOfWeek(dat));
      Console.WriteLine("Week of year: {0}\n", 
                        umAlQura.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                               DayOfWeek.Sunday));

      var greg = new GregorianCalendar(); 
      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Day of Week: {0}", dat.DayOfWeek);
      Console.WriteLine("Week of year: {0}", 
                         greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                            DayOfWeek.Sunday));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Day of Week: Tuesday
//       Week of year: 34
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Day of Week: Tuesday
//       Week of year: 46

날짜 및 달력에 대 한 자세한 내용은 참조 하십시오. 달력 작업합니다.

지속할 수 있습니다 DateTime 네 가지 방법으로 값:

선택한 하는 방법에 관계 없이 확인 해야 하는 복원 하는 루틴의 DateTime 값 데이터가 손실 또는 예외를 throw 하지 않습니다. DateTime값 라운드트립 합니다. 즉, 원래 값과 복원된 값 동일 해야 합니다. 경우에 원래 DateTime 값 단일 시간 인스턴스에만 나타내는 시간 복원 된 경우 동일한 순간을 식별 해야 합니다.

성공적으로 복원 하려면 DateTime 유지 되는 값을 문자열로 같은이 규칙을 따릅니다.

  • 문화권별 형식으로 유지 때 해당 문자열을 복원 하는 경우를 지정 하는 방법에 대 한 동일한 가정을 확인 합니다. 현재 문화권이에 저장 된 시스템의 culture와에서 다른 시스템에는 문자열을 복원할 수 있도록 하려면 호출는 ToString오버 로드는 고정 문화권 및 호출 규칙을 사용 하 여 문자열을 저장 하는 Parse(String, IFormatProvider, DateTimeStyles) 또는 TryParse(String, IFormatProvider, DateTimeStyles, DateTime) 고정 문화권의 규칙을 사용 하 여 문자열을 복원 하는 오버 로드 합니다. 사용 하지 않습니다는 ToString(), Parse(String), 또는 TryParse(String, DateTime) 오버 로드를 현재 스레드 문화권의 규칙을 사용 합니다.

  • 데이터는 시간의 단일 시점을 나타내는 경우에 다른 표준 시간대를 사용 하는 시스템에서 복원 된 경우에 나타내는 동일한 순간에 복원 될 때 확인 합니다. 이 작업을 수행 하려면 변환는 DateTime utc (협정 세계시)로 저장 하기 전에 값입니다. 표준 시간대 정보가; 함께 값도 serialize 할 수 있습니다. 이 방법을 사용 하는 방법에 대 한 자세한 내용은 참조 직렬화 날짜/시간 및 표준 시간대 데이터합니다.

지속할 때 가장 일반적인 오류 DateTime 값을 문자열로 기본 문화권 이나 현재 문화권의 서식 지정 규칙을 사용 하는 것입니다. 현재 문화권이 저장 하 고 문자열을 복원할 때 서로 다른 경우 문제가 발생 합니다. 다음 예제에서는 이러한 문제를 보여 줍니다. 이 경우에 영어 (미국)는 현재 문화권의 서식 지정 규칙을 사용 하 여 5 개 날짜를 저장 합니다. 이 경우에 영어 (영국)는 현재 문화권의 서식 지정 규칙을 사용 하 여 날짜를 복원 합니다. 이기 때문에 두 개의 문화권의 형식 규칙이 서로 다른 두 날짜를 복원할 수 없는 하 고 나머지 세 개의 날짜 올바르게 해석 됩니다. 또한 원래 날짜 및 시간 값은 복원 된 시간 내에 단일 시점을 나타내는 경우 표준 시간대 정보가 손실 되기 때문에 시간이 올바르지 않습니다.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\BadDates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParse(inputValue, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", inputValue, dateValue);
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

왕복 하는 데 DateTime 다음이 단계를 성공적으로 수행 하는 값:

  1. 시간의 단일 시점을 나타내는 경우 변환 현지 시간에서 UTC로 호출 하 여는 ToUniversalTime 메서드.

  2. 날짜를 호출 하 여 해당 문자열 표현으로 변환 된 ToString(String, IFormatProvider) 또는 String.Format(IFormatProvider, String, Object[]) 오버 로드 합니다. 고정 문화권의 서식 지정 규칙을 사용 하 여 지정 하 여 CultureInfo.InvariantCultureprovider 인수입니다. 값이 "O" 또는 "R"을 사용 하 여에 왕복 해야 지정 합니다.

  3. 호출 하는 경우는 Parse(String, IFormatProvider, DateTimeStyles) 또는 TryParse(String, IFormatProvider, DateTimeStyles, DateTime) 메서드.

유지 되 복원 하려면 DateTime 데이터 손실 없이 값에서 다음을 수행 합니다.

  1. 호출 하 여 데이터를 구문 분석 된 ParseExact 또는 TryParseExact 오버 로드 합니다. 지정 CultureInfo.InvariantCultureprovider 인수와 같은 표준 형식 문자열에 사용 되는 사용 하 여는 format 변환 하는 동안 인수입니다. 포함 된 DateTimeStyles.RoundtripKind 값에 styles 인수입니다.

  2. 경우는 DateTime 값은 호출 시간 내에 단일 시점을 나타냅니다는 ToLocalTime 현지 시간으로 측정 된 UTC에서 구문 분석 된 날짜를 변환 하는 메서드입니다.

다음 예제에서는 고정 문화권 및 "O" 표준 서식 문자열 사용 하 여 되도록 DateTime 저장 되 고 복원 하는 값은 시스템, 문화권 또는 원본 시스템과 대상 시스템의 표준 시간대에 관계 없이 동일한 순간을 나타냅니다.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\Dates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) 
                   + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, 
                               DateTimeStyles.RoundtripKind, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", 
                              inputValue, dateValue.ToLocalTime());
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

유지 하는 대신 한 DateTime 값을 문자열로 유지할 수 있습니다는 Int64 틱 수를 나타내는 값입니다. 이 경우에 시스템의 문화권을 고려 필요가 없습니다는 DateTime 값 유지 되며에 복원 합니다.

유지 하는 DateTime 정수는 값:

  • 경우는 DateTime 값에에서 단일 시점을 나타내는, 호출 하 여 UTC로 변환 된 ToUniversalTime 메서드.

  • 가 나타내는 틱 수를 검색 된 DateTime 값에서 해당 Ticks 속성입니다.

복원 하는 DateTime 를 정수로 유지 된 값:

  1. DateTime 전달 하 여 개체는 Int64 값을 DateTime(Int64) 생성자입니다.

  2. 경우는 DateTime 값의에서 단일 한 시점을 나타내는 변환 측정 된 UTC에서 로컬 시간으로 호출 하 여는 ToLocalTime 메서드.

다음 예제에서는 배열을 계속 되 면 DateTime 은 미국 영어 시스템에는 정수 값 표시합니다. UTC 표준 시간대에 있는 시스템에 복원 합니다. 정수를 포함 하는 파일에 포함 되어는 Int32 의 총 수를 나타내는 값 Int64 것 바로 뒤에 값입니다.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

class Example
{
   private const string filename = @".\IntDates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      long[] ticks = new long[dates.Length];
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         ticks[ctr] = dates[ctr].ToUniversalTime().Ticks; 
      }
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryWriter bw = new BinaryWriter(fs);
      bw.Write(ticks.Length);
      foreach (var tick in ticks)
         bw.Write(tick);

      bw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryReader br = new BinaryReader(fs);
      int items;
      DateTime[] dates;

      try { 
         items = br.ReadInt32();
         dates = new DateTime[items];

         for (int ctr = 0; ctr < items; ctr++) {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
         }
      }   
      catch (EndOfStreamException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }   
      catch (IOException) {
         Console.WriteLine("Unspecified I/O error. Unable to restore data...");
         return;
      }
      // Thrown during array initialization.
      catch (OutOfMemoryException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }
      finally {      
         br.Close();
      }   

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

저장 하는 대신 DateTime 에 값을 문자열 또는 정수로 변환 해야 하는 다음으로 다시 DateTime 유지할 수 값을 DateTime 값 스트림 또는 파일 및 다음 복원 하는 serialization을 통해 해당 deserialization을 통해. 이 경우 DateTime일부 지정 된 개체 형식으로 데이터를 serialize 및 deserialize 하는 개체가 복원 됩니다. 포맷터 또는, 직렬 변환기와 같은 XmlSerializer 또는 BinaryFormatter, serialization 및 deserialization 프로세스를 처리 합니다. Serialization 및.NET Framework에서 지원 되는 serialization 형식에 대 한 자세한 내용은 참조 Serialization합니다.

다음 예제에서는 XmlSerializer serialize 및 deserialize 하는 클래스 DateTime 21 세기 연도의 일에 들어오는 모든을 나타내는 값입니다. 이 예제에서는 현재 문화권이 영어 (영국) 인 시스템에서 실행 되 면 출력 결과를 나타냅니다. 역직렬화 한 우리 때문에 DateTime 개체 자체에 코드의 날짜 및 시간 형식 문화적 차이 처리할 필요가 없습니다.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Xml.Serialization;

class Example
{
   private const string filename = @".\LeapYears.xml";

   public static void Main()
   {
      // Serialize the data.
      List<DateTime> leapYears = new List<DateTime>();
      for (int year = 2000; year <= 2100; year += 4) {
         if (DateTime.IsLeapYear(year)) 
            leapYears.Add(new DateTime(year, 2, 29));
      }
      DateTime[] dateArray = leapYears.ToArray();

      XmlSerializer serializer = new XmlSerializer(dateArray.GetType());
      TextWriter sw = new StreamWriter(filename);

      try {
         serializer.Serialize(sw, dateArray);
      }
      catch (InvalidOperationException e) {
         Console.WriteLine(e.InnerException.Message);         
      }
      finally {
         if (sw != null) sw.Close();
      }   

      // Deserialize the data.
      DateTime[] deserializedDates;
      using (FileStream fs = new FileStream(filename, FileMode.Open)) {
         deserializedDates = (DateTime[]) serializer.Deserialize(fs);
      } 

      // Display the dates.
      Console.WriteLine("Leap year days from 2000-2100 on an {0} system:",
                        Thread.CurrentThread.CurrentCulture.Name);
      int nItems = 0;
      foreach (var dat in deserializedDates) {
         Console.Write("   {0:d}     ", dat);
         nItems++;
         if (nItems % 5 == 0) 
               Console.WriteLine(); 
      }
   }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

앞의 예제에는 시간 정보가 포함 되지 않습니다. 그러나 경우는 DateTime 변환 해야 현지 시간에서 UTC로 호출 하 여 직렬화 하기 전에, 값의에서 한 시점을 나타내며 현지 시간으로 표현 된 ToUniversalTime 메서드. 를 deserialize 하는 후 변환 해야 측정 된 UTC에서 로컬 시간으로 호출 하 여는 ToLocalTime 메서드. 다음 예제에서는 BinaryFormatter serialize 하는 클래스DateTime 은 미국 영어 시스템의 데이터 태평양 표준 시간대를 UTC 표준 시간대에 있는 시스템에서 deserialize 하 고 있습니다.

using System;
using System.IO;
using System.Globalization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;

class Example
{
   private const string filename = @".\Dates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryFormatter bin = new BinaryFormatter();

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         dates[ctr] = dates[ctr].ToUniversalTime();
      }
      bin.Serialize(fs, dates);
      fs.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryFormatter bin = new BinaryFormatter();
      DateTime[] dates = (DateTime[]) bin.Deserialize(fs);
      fs.Close();

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToLocalTime().ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

앞의 예제에서는 모든 독자를 대상으로 하는 DateTime 값 현지 시간으로 표현 되 고 UTC와 현지 시간 사이의 값을 변환 하는 동일한 순간에에서 원본 및 대상 시스템에 반영 되므로 합니다. DateTime값에 로컬이 아닌 다른 표준 시간대와 UTC 시간 또한 반영할 수 있습니다. 이 경우 때문에 DateTime 구조체가 표준 시간대 인식, 모두 serialize 할는 DateTime값 및 TimeZoneInfo 해당 표준 시간대를 나타내는 개체입니다. 이 수행 하려면 해당 필드는 둘 모두 형식을 만들는 DateTime 값과 해당 표준 시간대입니다. 다음 예제에서는 정의 DateWithTimeZone 구조를이 수행 방법을 보여 줍니다.

using System;

namespace DateTimeExtensions
{
   [Serializable] public struct DateWithTimeZone
   {
      private TimeZoneInfo tz;
      private DateTime dt;

      public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
      {
         dt = dateValue;
         if (timeZone == null)
            tz = TimeZoneInfo.Local;
         else
            tz = timeZone;
      }   

      public TimeZoneInfo TimeZone 
      { get { return (tz); }
        set { tz = value; } }

      public DateTime DateTime 
      { get { return (dt); }
        set { dt = value; } }
   }
}
System_CAPS_important중요

DateWithTimeZone 구조가 serialize 및 deserialize 배열을 다음 두 예제에서 사용 DateWithTimeZone 개체입니다. 예를 실행 하려면 먼저 포함 하는 클래스 라이브러리 만들기는 DateWithTimeZone 구조, 한 다음 각 예제를 컴파일할 때에 대 한 참조를 추가 합니다.

사용 하 여는 DateWithTimeZone 구조를 다음 날짜 및 시간과 표준 시간대 정보를 유지할 수 있습니다. 다음 예제에서는 BinaryFormatter 의 배열을 serialize 하는 클래스 DateWithTimeZone개체입니다.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   public static void Main()
   {
      DateWithTimeZone[] dates= { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
      FileStream fs = new FileStream(@".\Schedule.bin", FileMode.Create);
      BinaryFormatter formatter = new BinaryFormatter();
      try {
         formatter.Serialize(fs, dates);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Serialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

다음 예제에서는 다음 호출에서 BinaryFormatter.Deserialize 메서드를 역직렬화 하는 것입니다.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   private const string filename = @".\Schedule.bin";

   public static void Main()
   {
      FileStream fs;
      if (File.Exists(filename))
         fs = new FileStream(filename, FileMode.Open);
      else {
         Console.WriteLine("Unable to find file to deserialize.");
         return;
      }

      BinaryFormatter formatter = new BinaryFormatter();
      DateWithTimeZone[] dates;
      try {
         dates = (DateWithTimeZone[]) formatter.Deserialize(fs);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Deserialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

A DateTime 왕복 하는 데는 COM 응용 프로그램으로 전송 되는 다음 관리 되는 응용 프로그램으로 다시 전송 되는 값 이라고 합니다. 그러나는 DateTime 한 번만 지정 하는 값에는 없는 예상 대로 라운드트립 합니다.

라운드트립 오후 3 시, 최종 날짜 및 시간과 같은 시간만 오후 3시 년 1 월 1 일 대신 서 기 0001 C.E. 1899 년 12 월 30 일 오후 3 시에 경우 .NET Framework 및 COM에는 한 번만 지정 된 경우 기본 날짜 가정 하기 때문에 발생 합니다. .NET Framework는 서 기 0001 년 1 월 1 일의 기본 날짜를 가정 하는 동안 COM 시스템 C.E. 1899 년 12 월 30 일의 기본 날짜를 가정 하는 반면

한 번만이.NET Framework에서 COM에 전달 되 면 특수 처리는 수행 시간 com 사용 되는 형식으로 변환 하는 .NET Framework에 COM에서 한 번만이 전달 되 면 올바른 날짜와 시간이 나 그 1899 년 12 월 30 일 이전에 손상 될 수 있으므로 없는 특별 한 처리가 수행 됩니다. 즉, 날짜의 라운드트립 COM에서 시작 하는 경우.NET Framework 및 COM 유지할 날짜입니다.

.NET Framework 및 COM의 동작으로 인해 되는 경우 응용 프로그램 왕복은 DateTime 한 번만 지정 하는, 응용 프로그램을 수정 하거나 최종에서 잘못 된 날짜를 무시 기억해 야 DateTime 개체입니다.

다음 예제에서는 대략 비교 하는 방법을 해당 DateTime 값을 같은 선언 작은 간격 차이 수락 합니다.

using System;

class DateTimeTester 
{
   static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
   {
      long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds 
                                                     % frequencyInSeconds;

      delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;

      return Math.Abs(delta) < windowInSeconds;
	}

	public static void Main() 
	{
      int window = 10;
      int freq = 60 * 60 * 2; // 2 hours;

      DateTime d1 = DateTime.Now;

      DateTime d2 = d1.AddSeconds(2 * window);
      DateTime d3 = d1.AddSeconds(-2 * window);
      DateTime d4 = d1.AddSeconds(window / 2);
      DateTime d5 = d1.AddSeconds(-window / 2);

      DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
      DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
      DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
      DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

      Console.WriteLine("d1 ({0}) ~= d1 ({1}): {2}",
                        d1, d1, RoughlyEquals(d1, d1, window, freq));
      Console.WriteLine("d1 ({0}) ~= d2 ({1}): {2}", 
                        d1, d2, RoughlyEquals(d1, d2, window, freq));
      Console.WriteLine("d1 ({0}) ~= d3 ({1}): {2}", 
                        d1, d3, RoughlyEquals(d1, d3, window, freq));
      Console.WriteLine("d1 ({0}) ~= d4 ({1}): {2}", 
                        d1, d4, RoughlyEquals(d1, d4, window, freq));
      Console.WriteLine("d1 ({0}) ~= d5 ({1}): {2}", 
                        d1, d5, RoughlyEquals(d1, d5, window, freq));

      Console.WriteLine("d1 ({0}) ~= d6 ({1}): {2}", 
                        d1, d6, RoughlyEquals(d1, d6, window, freq));
      Console.WriteLine("d1 ({0}) ~= d7 ({1}): {2}", 
                        d1, d7, RoughlyEquals(d1, d7, window, freq));
      Console.WriteLine("d1 ({0}) ~= d8 ({1}): {2}", 
                        d1, d8, RoughlyEquals(d1, d8, window, freq));
      Console.WriteLine("d1 ({0}) ~= d9 ({1}): {2}", 
                        d1, d9, RoughlyEquals(d1, d9, window, freq));
	}
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

유니버설 Windows 플랫폼
8 이후 사용 가능
.NET Framework
1.1 이후 사용 가능
이식 가능한 클래스 라이브러리
이식 가능한 .NET 플랫폼 에서 지원됨
Silverlight
2.0 이후 사용 가능
Windows Phone Silverlight
7.0 이후 사용 가능
Windows Phone
8.1 이후 사용 가능

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

System_CAPS_caution주의

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

맨 위로 이동
표시: