DateTime 구조체

정의

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

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IConvertible, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable
[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable
type DateTime = struct
    interface IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
상속
DateTime
특성
구현

설명

중요

일본어 달력의 시대는 천황 통치 기간을 기준으로 하므로 변경되어야 합니다. 예를 들어 2019년 5월 1일은 JapaneseCalendarJapaneseLunisolarCalendar에서 레이와 시대의 시작을 나타냅니다. 이러한 시대 변경 내용은 해당 달력을 사용하는 모든 애플리케이션에 영향을 줍니다. 자세한 내용 및 애플리케이션이 영향을 받는지 여부를 확인하려면 .NET에서 일본 달력의 새 시대 처리를참조하세요. Windows 시스템에서 애플리케이션을 테스트하여 시대 변화에 대한 준비 상태를 확인하는 자세한 내용은 일본 연호 변경을 위한 애플리케이션 준비를 참조하세요. 여러 시대가 있는 달력을 지원하는 .NET의 기능 및 여러 연호를 지원하는 달력으로 작업하는 경우 모범 사례는 연호 작업을 참조하세요.

참고

이 문서의 일부 C# 예제는 Try.NET 인라인 코드 실행기 및 플레이그라운드에서 실행됩니다. 대화형 창에서 예제를 실행하려면 실행 버튼을 선택합니다. 코드를 실행하면 실행 을 다시 선택하여 코드를 수정하고 수정된 코드를 실행할 수 있습니다. 수정된 코드는 대화형 창에서 실행되거나, 컴파일이 실패하면 대화형 창에 모든 C# 컴파일러 오류 메시지가 표시됩니다.

Try.NET 인라인 코드 러너와 플레이그라운드의 현지 표준 시간대는 협정 세계시(또는 UTC)입니다. 이는 DateTime, DateTimeOffsetTimeZoneInfo 형식과 이러한 형식의 멤버를 보여주는 예제의 동작 및 출력에 영향을 줄 수 있습니다.

이 문서에는 형식을 사용하는 몇 가지 예제가 DateTime 포함되어 있습니다.

초기화 예제

개체를 문자열로 서식 지정 DateTime

문자열을 개체로 DateTime 구문 분석

DateTime 해상도

문화권 및 일정

지속성

이 섹션에는 구조체의 일반적인 여러 용도에 대한 항목이 DateTime 포함되어 있습니다.

값 형식은 DateTime 00:00:00(자정), 0001년 1월 1일 안노 도미니(일반 시대)부터 9999년 12월 31일 오후 11:59:59까지의 값으로 날짜와 시간을 나타냅니다. (C.E.) 그레고리오력에서

시간 값은 틱이라고 하는 100나노초 단위로 측정됩니다. 특정 날짜는 서기 0001년 1월 1일 자정 12:00 이후의 틱 수입니다. (C.E.) 을 선택합니다 GregorianCalendar . 이 숫자는 윤초별로 추가될 틱을 제외합니다. 예를 들어 틱 값 3124137600000000000은 0100년 1월 1일 금요일 12:00:00 자정 날짜를 나타냅니다. DateTime 값은 항상 명시적 또는 기본 달력의 컨텍스트에서 표현됩니다.

참고

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

GitHub의 문서 리포지토리에서 Visual Basic, F#또는 C# 에서 이 문서의 전체 예제 집합에 대한 원본을 볼 수 있습니다.

참고

특정 표준 시간대의 DateTime 날짜 및 시간 값을 사용하기 위한 구조의 대안은 구조체입니다 DateTimeOffset . 구조체는 DateTimeOffset 날짜 및 시간 정보를 개인 필드에 저장하고 해당 날짜와 시간이 개인 DateTime Int16 필드의 UTC와 다른 시간(분)을 저장합니다. 이렇게 하면 DateTimeOffset 값이 특정 표준 시간대의 시간을 반영할 수 있는 반면 DateTime 값은 UTC 및 현지 표준 시간대의 시간만 명확하게 반영할 수 있습니다. 날짜 및 시간 값으로 작업할 때 구조체 또는 DateTimeOffset 구조를 사용하는 DateTime 시기에 대한 자세한 내용은 DateTime, DateTimeOffset, TimeSpan 및 TimeZoneInfo 중에서 선택을 참조하세요.

DateTime 개체 초기화

여러 가지 방법으로 새 DateTime 값에 초기 값을 할당할 수 있습니다.

  • 값에 대한 인수를 지정하거나 암시적 매개 변수가 없는 생성자를 사용하는 생성자를 호출합니다.
  • DateTime 속성 또는 메서드의 반환 값에 할당
  • DateTime 문자열 표현에서 값을 구문 분석합니다.
  • Visual Basic 관련 언어 기능을 DateTime사용하여 .

다음 코드 조각은 각각에 대한 예제를 보여 줍니다.

생성자 호출

날짜 및 시간 값의 DateTime 요소(예: 연도, 월, 일 또는 틱 수)를 지정하는 생성자의 오버로드를 호출합니다. 다음 코드는 연도, 월, 일, 시간, 분 및 초를 지정하는 생성자를 사용하여 DateTime 특정 날짜를 만듭니다.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);
let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"

기본값으로 DateTime 초기화하려는 DateTime 경우 구조체의 암시적 매개 변수 없는 생성자를 호출합니다. (값 형식의 암시적 매개 변수가 없는 생성자에 대한 자세한 내용은 값 형식을 참조 하세요.) 일부 컴파일러에서는 값을 명시적으로 할당하지 않고도 값 선언 DateTime 을 지원합니다. 명시적 초기화 없이 값을 만들면 기본값도 생성됩니다. 다음 예제에서는 C# 및 Visual Basic의 DateTime 암시적 매개 변수 없는 생성자와 Visual Basic에서 할당이 없는 선언을 DateTime 보여 줍니다.

Dim dat1 As 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(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var 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));
let dat1 = DateTime()

// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"

// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"
계산 값 할당

속성 또는 메서드에서 반환된 DateTime 날짜 및 시간 값을 개체에 할당할 수 있습니다. 다음 예제에서는 현재 날짜 및 시간, 현재 UTC(협정 세계시) 날짜 및 시간 및 현재 날짜를 세 개의 새 DateTime 변수에 할당합니다.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today
DateTime을 나타내는 문자열 구문 분석

, ParseExactTryParseTryParseExact 메서드는 Parse모두 문자열을 해당하는 날짜 및 시간 값으로 변환합니다. 다음 예제에서는 문자열 및 ParseExact 메서드를 사용하여 Parse 문자열을 구문 분석하고 값으로 DateTime 변환합니다. 두 번째 형식은 문자열 형식의 날짜 및 시간을 나타내는 ISO 8601 표준에서 지원하는 양식을 사용합니다. 이 표준 표현은 웹 서비스에서 날짜 정보를 전송하는 데 자주 사용됩니다.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);
let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

TryParseExact 메서드는 TryParse 문자열이 값의 DateTime 유효한 표현인지 여부를 나타내며, 값인 경우 변환을 수행합니다.

Visual Basic에 대한 언어별 구문

다음 Visual Basic 문은 새 DateTime 값을 초기화합니다.

Dim date1 As Date = #5/1/2008 8:30:52AM#

DateTime 값 및 해당 문자열 표현

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

날짜 및 시간 값의 모양을 문화권, 국제 표준, 애플리케이션 요구 사항 및 개인 기본 설정에 따라 달라 집니다. 이 구조는 DateTime 오버로드를 통해 날짜 및 시간 값의 ToString서식을 유연하게 지정할 수 있습니다. 기본 DateTime.ToString() 메서드는 현재 문화권의 짧은 날짜 및 긴 시간 패턴을 사용하여 날짜 및 시간 값의 문자열 표현을 반환합니다. 다음 예제에서는 기본 DateTime.ToString() 메서드를 사용합니다. 현재 문화권의 짧은 날짜 및 긴 시간 패턴을 사용하여 날짜와 시간을 표시합니다. en-US 문화권은 예제가 실행된 컴퓨터의 현재 문화권입니다.

var 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{date1.ToString()}"
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

서버가 클라이언트와 다른 문화권에 있을 수 있는 웹 시나리오를 지원하려면 특정 문화권의 날짜 형식을 지정해야 할 수 있습니다. 메서드를 사용하여 특정 문화권에서 DateTime.ToString(IFormatProvider) 짧은 날짜 및 장시간 표현을 만드는 문화권을 지정합니다. 다음 예제에서는 fr-FR 문화권에 대 한 짧은 날짜 및 긴 시간 패턴을 사용 하 여 날짜 및 시간을 표시 하는 메서드를 사용 합니다 DateTime.ToString(IFormatProvider) .

var 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR")}"""
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
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 문화권에 대한 전체 날짜 및 시간 패턴을 표시합니다.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString "F"}"""
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

마지막으로 메서드를 사용하여 DateTime.ToString(String, IFormatProvider) 문화권과 형식을 모두 지정할 수 있습니다. 다음 예제에서는 이 메서드를 DateTime.ToString(String, IFormatProvider) 사용하여 fr-FR 문화권에 대한 전체 날짜 및 시간 패턴을 표시합니다.

var 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString("F", new System.Globalization.CultureInfo "fr-FR")}"""
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

오버로드는 DateTime.ToString(String) 사용자 지정 형식 문자열과 함께 사용하여 다른 형식을 지정할 수도 있습니다. 다음 예제에서는 웹 서비스에 자주 사용되는 ISO 8601 표준 형식을 사용하여 문자열의 서식을 지정하는 방법을 보여 줍니다. Iso 8601 형식에는 해당 표준 형식 문자열이 없습니다.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00
Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00

값 서식 지정 DateTime 에 대한 자세한 내용은 표준 날짜 및 시간 형식 문자열 및 사용자 지정 날짜 및 시간 형식 문자열을 참조하세요.

문자열에서 DateTime 값 구문 분석

구문 분석에서는 날짜 및 시간의 문자열 표현을 값으로 DateTime 변환합니다. 일반적으로 날짜 및 시간 문자열 애플리케이션에 두 개의 서로 다른 사용:

  • 날짜와 시간은 다양한 형식을 사용하며 현재 문화권 또는 특정 문화권의 규칙을 반영합니다. 예를 들어, 애플리케이션 사용자에 해당 현재 문화권이 EN-US "2013 년 12 월 15" 또는 "2013 년 12 월 15 년"로 날짜 값을 입력 허용 현재 문화권이 engb인 사용자는 날짜 값을 "2013년 15월 12일" 또는 "2013년 12월 15일"로 입력할 수 있습니다.

  • 날짜 및 시간은 미리 정의된 형식으로 표시됩니다. 예를 들어, 애플리케이션으로 "20130103" 앱이 실행 되는 culture와 독립적으로 날짜를 serialize 합니다. 애플리케이션에 필요한 날짜는 현재 문화권의 간단한 날짜 형식으로 입력 합니다.

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

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

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

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    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($"   {badFormat}");
}
// Press "Run" to see the output.
System.Threading.Thread.CurrentThread.CurrentCulture <-
    System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"

let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()

printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
    match DateTime.TryParse dateString with
    | true, parsedDate ->
        printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
    | _ ->
        badFormats.Add dateString

// Display strings that could not be parsed.
if badFormats.Count > 0 then
    printfn "\nStrings that could not be parsed: "
    for badFormat in badFormats do
        printfn $"   {badFormat}"
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' 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

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

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,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {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
let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings = 
    [ "20130816"; "20131608"; "  20130816   "
      "115216"; "521116"; "  115216  " ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, null,
                                System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
                                System.Globalization.DateTimeStyles.AdjustToUniversal) with
    | true, parsedDate ->
        printfn $"{dateString} --> {parsedDate:g}"
    | _ ->
        printfn $"Cannot convert {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
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' 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

한 가지 일반적인 용도 ParseExact 는 일반적으로 ISO 8601 표준 형식의 웹 서비스에서 문자열 표현을 변환하는 것입니다. 다음 코드는 사용할 올바른 형식 문자열을 보여줍니다.

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

printfn $"{iso8601String} --> {dateISO8602:g}"
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

문자열을 구문 분석할 수 없는 경우 및 ParseExact 메서드는 Parse 예외를 throw합니다. 및 TryParseExact 메서드는 TryParse 변환이 성공했는지 아니면 실패했는지를 나타내는 값을 반환 Boolean 합니다. 성능이 TryParse 중요한 시나리오에서 또는 TryParseExact 메서드를 사용해야 합니다. 날짜 및 시간 문자열에 대한 구문 분석 작업은 실패율이 높고 예외 처리 비용이 많이 드는 경향이 있습니다. 문자열이 사용자가 입력하거나 알 수 없는 원본에서 오는 경우 이러한 메서드를 사용합니다.

날짜 및 시간 값 구문 분석에 대한 자세한 내용은 날짜 및 시간 문자열 구문 분석을 참조하세요.

DateTime 값

형식의 시간 값에 대한 DateTime 설명은 UTC(협정 세계시) 표준을 사용하여 표현되는 경우가 많습니다. 조정된 유니버설 타임은 그리니치 표준시(GMT)의 국제적으로 인정받는 이름입니다. 조정된 유니버설 타임은 UTC 원점인 경도 0도로 측정된 시간입니다. 일광 절약 시간은 UTC에 적용되지 않습니다.

현지 시간은 특정 표준 시간대를 기준으로 합니다. 표준 시간대는 표준 시간대 오프셋과 연결됩니다. 표준 시간대 오프셋은 UTC 원본 지점에서 몇 시간 단위로 측정된 표준 시간대의 변위입니다. 또한 현지 시간은 필요에 따라 일광 절약 시간의 영향을 받으며 시간 간격 조정을 추가하거나 뺍니다. 현지 시간은 UTC에 표준 시간대 오프셋을 추가하고 필요한 경우 일광 절약 시간을 조정하여 계산됩니다. UTC 원본 지점의 표준 시간대 오프셋은 0입니다.

UTC 시간은 계산, 비교 및 날짜 및 시간을 파일에 저장하는 데 적합합니다. 현지 시간 데스크톱 애플리케이션의 사용자 인터페이스에 표시 하기에 적합합니다. 표준 시간대 인식 애플리케이션 (예: 여러 웹 애플리케이션)는 또한 다양 한 다른 표준 시간대를 사용 하 여 작업 해야 합니다.

개체의 Kind DateTime 속성이 DateTimeKind.Unspecified면 표시되는 시간이 현지 시간, UTC 시간 또는 다른 표준 시간대의 시간인지 지정되지 않습니다.

DateTime 확인

참고

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

이 속성은 Ticks 날짜 및 시간 값을 1초의 1,000만 단위로 표현합니다. 이 속성은 Millisecond 날짜 및 시간 값에서 1/10000초를 반환합니다. 속성에 대한 반복 호출을 DateTime.Now 사용하여 경과 시간을 측정하는 것은 시스템 클록에 따라 달라집니다. Windows 7 및 Windows 8 시스템의 시스템 클록의 해상도는 약 15밀리초입니다. 이 해상도는 100밀리초 미만의 작은 시간 간격에 영향을 줍니다.

다음 예제에서는 시스템 클록의 해상도에 대한 현재 날짜 및 시간 값의 의존성을 보여 줍니다. 이 예제에서 외부 루프는 20번 반복되고 내부 루프는 외부 루프를 지연시키는 역할을 합니다. 외부 루프 카운터의 값이 10이면 메서드를 호출하면 Thread.Sleep 5밀리초 지연이 발생합니다. 다음 예제에서는 호출 Thread.Sleep후에만 속성에서 반환되는 DateTime.Now.Milliseconds 시간(밀리초)을 보여 줍니다.

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.
let mutable output = ""
for i = 0 to 20 do
    output <- output + $"{DateTime.Now.Millisecond}\n"
    // Introduce a delay loop.
    for _ = 0 to 1000 do ()

    if i = 10 then
        output <- output + "Thread.Sleep called...\n"
        System.Threading.Thread.Sleep 5

printfn $"{output}"
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

DateTime 작업

구조체(예: 또는Subtract)를 Add 사용하는 DateTime 계산은 구조체의 값을 수정하지 않습니다. 대신 계산은 해당 값이 계산의 결과인 새 DateTime 구조를 반환합니다.

표준 시간대 간 변환 작업(예: UTC와 현지 시간 사이 또는 표준 시간대와 다른 표준 시간대 간)은 일광 절약 시간을 고려하지만 산술 및 비교 작업은 고려하지 않습니다.

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

개체의 계산 및 비교 DateTime 는 개체가 동일한 표준 시간대의 시간을 나타내는 경우에만 의미가 있습니다. 개체를 TimeZoneInfo 사용하여 값의 표준 시간대를 DateTime 나타낼 수 있지만 둘은 느슨하게 결합됩니다. DateTime 개체에는 해당 날짜 및 시간 값의 표준 시간대를 나타내는 개체를 반환하는 속성이 없습니다. 이 속성은 Kind UTC, 현지 시간을 나타내는지 DateTime 또는 지정되지 않은지를 나타냅니다. 표준 시간대 인식 애플리케이션에서 사용 해야 합니다는 표준 시간대를 확인 하는 일부 외부 메커니즘을 DateTime 개체가 만들어진 합니다. 값과 TimeZoneInfo 값의 표준 시간대를 나타내는 개체를 모두 DateTime 래핑하는 구조를 사용할 수 있습니다DateTime. 계산에 UTC를 사용하고 값과 DateTime 비교하는 방법에 대한 자세한 내용은 날짜 및 시간을 사용하여 산술 연산 수행을 참조하세요.

DateTime 멤버는 음력 달력을 암시적으로 사용하여 작업을 수행합니다. 예외는 달력을 암시적으로 지정하는 메서드입니다. 여기에는 달력을 지정하는 생성자와 파생된 매개 변수가 있는 메서드(예: System.Globalization.DateTimeFormatInfo.)가 포함됩니다IFormatProvider.

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

DateTime 값 및 일정

.NET Framework 클래스 라이브러리에는 다양한 일정 클래스가 포함되어 있으며, 모두 클래스에서 Calendar 파생됩니다. 다음 창이 여기에 포함됩니다.

중요

일본어 달력의 시대는 천황 통치 기간을 기준으로 하므로 변경되어야 합니다. 예를 들어 2019년 5월 1일은 JapaneseCalendarJapaneseLunisolarCalendar에서 레이와 시대의 시작을 나타냅니다. 이러한 시대 변경 내용은 해당 달력을 사용하는 모든 애플리케이션에 영향을 줍니다. 자세한 내용 및 애플리케이션이 영향을 받는지 여부를 확인하려면 .NET에서 일본 달력의 새 시대 처리를참조하세요. Windows 시스템에서 애플리케이션을 테스트하여 시대 변화에 대한 준비 상태를 확인하는 자세한 내용은 일본 연호 변경을 위한 애플리케이션 준비를 참조하세요. 여러 시대가 있는 달력을 지원하는 .NET의 기능 및 여러 연호를 지원하는 달력으로 작업하는 경우 모범 사례는 연호 작업을 참조하세요.

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

문화권의 현재 달력은 해당 문화권에 대한 모든 서식 지정 작업에 사용됩니다. 예를 들어 태국 불교 문화의 기본 달력은 클래스가 나타내는 ThaiBuddhistCalendar 태국 불교 시대 달력입니다. CultureInfo 태국 불교 문화를 나타내는 개체가 날짜 및 시간 서식 작업에 사용되는 경우 태국 불교 시대 달력은 기본적으로 사용됩니다. 다음 예제와 같이 문화권의 DateTimeFormatInfo.Calendar 속성이 변경된 경우에만 그레고리오력이 사용됩니다.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

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

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)

printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()

printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

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

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

매개 변수가 DateTime 포함된 calendar DateTime 생성자를 호출하고 해당 달력을 나타내는 개체를 전달 Calendar 하여 특정 달력의 날짜 및 시간 요소(연도, 월 및 일 수)를 사용하여 값을 인스턴스화합니다. 다음 예제에서는 달력의 날짜 및 시간 요소를 ThaiBuddhistCalendar 사용합니다.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016
let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)

printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"Gregorian date:   {dat:d}"

// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime 매개 변수를 포함하지 calendar 않는 생성자는 날짜 및 시간 요소가 그레고리오력의 단위로 표현된다고 가정합니다.

다른 DateTime 모든 속성 및 메서드는 그레고리력 달력을 사용합니다. 예를 들어 속성은 DateTime.Year 그레고리오력에서 연도를 반환하고 DateTime.IsLeapYear(Int32) 메서드는 매개 변수가 year 그레고리오력의 연도라고 가정합니다. 양력 달력을 사용하는 각 DateTime 멤버에는 특정 달력을 Calendar 사용하는 클래스의 해당 멤버가 있습니다. 예를 들어 메서드는 Calendar.GetYear 특정 달력에서 연도를 반환하고 메서드는 Calendar.IsLeapYear 매개 변수를 특정 달력의 year 연도 번호로 해석합니다. 다음 예제에서는 클래스의 DateTime 해당 멤버와 해당 멤버를 ThaiBuddhistCalendar 모두 사용합니다.

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True
let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"

printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

구조에는 DateTime 그레고리오력에서 요일을 반환하는 속성이 포함됩니다 DayOfWeek . 연도의 주 수를 검색할 수 있는 멤버는 포함되지 않습니다. 연도의 주를 검색하려면 개별 일정의 Calendar.GetWeekOfYear 메서드를 호출합니다. 다음 예제에서 이에 대해 설명합니다.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34
let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"

let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

날짜 및 일정에 대한 자세한 내용은 일정 작업을 참조하세요.

DateTime 값 유지

다음 네 가지 방법으로 값을 유지할 DateTime 수 있습니다.

값을 복원 DateTime 하는 루틴이 어떤 기술을 선택하든 데이터를 손실하거나 예외를 throw하지 않도록 해야 합니다. DateTime 값은 왕복해야 합니다. 즉, 원래 값과 복원된 값은 동일해야 합니다. 또한 원래 DateTime 값이 단일 시간 인스턴스를 나타내는 경우 복원되는 동일한 시간을 식별해야 합니다.

값을 문자열로 유지

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

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

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{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...
let saveLocalDatesAsString () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date}"
            string date ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreLocalDatesFromString () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParse inputValue with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue:f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsLocalStrings () =
    saveLocalDatesAsString ()
    restoreLocalDatesFromString ()

// 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...
Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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. 값이 단일 시간 순간을 나타내는 경우 메서드를 호출 ToUniversalTime 하여 현지 시간에서 UTC로 변환합니다.
  2. 또는 String.Format(IFormatProvider, String, Object[]) 오버로드를 호출하여 날짜를 문자열 표현으로 ToString(String, IFormatProvider) 변환합니다. 인수로 provider 지정 CultureInfo.InvariantCulture 하여 고정 문화권의 서식 규칙을 사용합니다. "O" 또는 "R" 표준 형식 문자열을 사용하여 값이 왕복되도록 지정합니다.

데이터 손실 없이 지속형 DateTime 값을 복원하려면 다음 단계를 수행합니다.

  1. 또는 TryParseExact 오버로드를 호출 ParseExact 하여 데이터를 구문 분석합니다. 인수로 provider 지정 CultureInfo.InvariantCulture 하고 변환 중에 인수에 사용한 것과 동일한 표준 형식 문자열을 format 사용합니다. 인수에 DateTimeStyles.RoundtripKind styles 값을 포함합니다.
  2. 값이 시간 단위 DateTime 의 단일 순간을 나타내는 경우 구문 분석된 날짜를 UTC에서 현지 시간으로 변환하는 메서드를 호출 ToLocalTime 합니다.

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

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        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...
let saveDatesAsInvariantStrings () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreDatesAsInvariantStrings () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    
    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsInvariantStrings () =
    saveDatesAsInvariantStrings ()
    restoreDatesAsInvariantStrings ()

// 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...
Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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...
값을 정수로 유지

날짜와 시간을 여러 틱을 Int64 나타내는 값으로 유지할 수 있습니다. 이 경우 값이 유지되고 복원되는 시스템의 DateTime 문화권을 고려할 필요가 없습니다.

값을 정수로 유지 DateTime 하려면 다음을 수행합니다.

  • 값이 시간 단위 DateTime 의 단일 순간을 나타내는 경우 메서드를 호출 ToUniversalTime 하여 UTC로 변환합니다.
  • 해당 속성에서 값으로 DateTime 표시되는 틱 수를 검색합니다 Ticks .

정수로 DateTime 유지된 값을 복원하려면 다음을 수행합니다.

  1. 생성자에 값을 전달 Int64 하여 새 DateTime 개체를 DateTime(Int64) 인스턴스화합니다.
  2. 값이 DateTime 한 순간의 시간을 나타내는 경우 메서드를 호출 ToLocalTime 하여 UTC에서 현지 시간으로 변환합니다.

다음 예제에서는 값 배열을 미국 태평양 표준 시간대의 DateTime 시스템에 정수로 유지합니다. UTC 영역의 시스템에서 복원합니다. 정수가 포함된 파일에는 바로 뒤에 있는 총 값 수를 Int64 나타내는 값이 포함 Int32 됩니다.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var 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;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var 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 RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, 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 {Thread.CurrentThread.CurrentCulture.Name} system:");
    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...
let saveDatesAsInts () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    let ticks =
        [| for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().Ticks |]
    use fs = new FileStream(filenameInts, FileMode.Create)
    use bw = new BinaryWriter(fs)
    bw.Write ticks.Length

    for tick in ticks do
        bw.Write tick

    printfn "Saved dates..."

let restoreDatesAsInts () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    use fs = new FileStream(filenameInts, FileMode.Open)
    use br = new BinaryReader(fs)

    try
        let items = br.ReadInt32()
        let dates =
            [| for _ in 0..items do
                let ticks = br.ReadInt64()
                DateTime(ticks).ToLocalTime() |]

        printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
        for value in dates do
            printfn $"{value:f}"
    with 
    | :? EndOfStreamException ->
        printfn "File corruption detected. Unable to restore data..."
    | :? IOException ->
        printfn "Unspecified I/O error. Unable to restore data..."
    // Thrown during array initialization.
    | :? OutOfMemoryException ->
        printfn"File corruption detected. Unable to restore data..."

    printfn "Restored dates..."

let persistAsIntegers () =
    saveDatesAsInts ()
    restoreDatesAsInts ()

// 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...
Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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 데이터는 지정된 개체 형식으로 직렬화됩니다. 개체는 역직렬화될 때 복원됩니다. 포맷터 또는 직렬 변환기(예: XmlSerializer 또는 BinaryFormatter)는 직렬화 및 역직렬화 프로세스를 처리합니다. serialization 및 .NET Framework 지원하는 serialization 유형에 대한 자세한 내용은 Serialization을 참조하세요.

다음 예제에서는 클래스를 XmlSerializer 사용하여 값을 직렬화하고 역직렬화합니다 DateTime . 값은 21세기의 모든 윤년일을 나타냅니다. 현재 문화권이 영어(영국)인 시스템에서 예제가 실행되는 경우 출력은 결과를 나타냅니다. 개체 자체를 역직렬화 DateTime 했으므로 코드는 날짜 및 시간 형식의 문화권 차이를 처리할 필요가 없습니다.

public static void PersistAsXML()
{
    // Serialize the data.
    var 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();

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

    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 (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[])serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    foreach (var dat in deserializedDates)
    {
        Console.Write($"   {dat:d}     ");
        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
let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

// 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
Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' 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 특정 시간을 나타내고 현지 시간으로 표현되는 경우 메서드를 호출 ToUniversalTime 하여 직렬화하기 전에 현지 시간에서 UTC로 변환합니다. 역직렬화한 후 메서드를 호출 ToLocalTime 하여 UTC에서 현지 시간으로 변환합니다. 다음 예제에서는 클래스를 BinaryFormatter 사용하여 미국 태평양 표준 시간대의 시스템에서 데이터를 직렬화 DateTime 하고 미국 중부 표준 시간대의 시스템에서 역직렬화합니다.

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    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) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

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

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
// BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDatesBinary () =
    let dates = 
        [| DateTime(2014, 6, 14, 6, 32, 0)
           DateTime(2014, 7, 10, 23, 49, 0)
           DateTime(2015, 1, 10, 1, 16, 0)
           DateTime(2014, 12, 20, 21, 45, 0)
           DateTime(2014, 6, 2, 15, 14, 0) |]
        |> Array.map (fun date -> 
            printfn $"{date:f}"
            date.ToUniversalTime() )

    use fs = new FileStream(filenameBin, FileMode.Create)
    let bin = BinaryFormatter()

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    bin.Serialize(fs, dates)
    printfn "Saved dates..."

let restoreDatesBinary () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use fs = new FileStream(filenameBin, FileMode.Open)
    let bin = BinaryFormatter()
    let dates = bin.Deserialize fs :?> DateTime []

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    for value in dates do
        printfn $"{value.ToLocalTime():f}"

    printfn "Restored dates..."

let persistBinary () =
    saveDatesBinary ()
    restoreDatesBinary ()

// 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-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

DateTime 및 표준 시간대 데이터 직렬화

이전 예제에서는 모두 값이 DateTime 로컬 시간으로 표현되었다고 가정했습니다. 이 코드는 UTC와 현지 시간 사이의 값을 변환하여 원본 및 대상 시스템에서 동일한 시간을 반영합니다. DateTime 값은 로컬 및 UTC 이외의 표준 시간대에서 시간의 순간을 반영할 수도 있습니다. 구조체가 DateTime 표준 시간대를 인식하지 않으므로 해당 표준 시간대를 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;
            tz = timeZone ?? TimeZoneInfo.Local;
        }

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

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
namespace DateTimeExtensions

open System

[<Serializable>]
type DateWithTimeZone =
    struct
        val TimeZone: TimeZoneInfo
        val DateTime: DateTime
        new (dateValue, timeZone) = 
            { DateTime = dateValue; 
              TimeZone = 
                if isNull timeZone then TimeZoneInfo.Local
                else timeZone }
    end
Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

중요

구조체 DateWithTimeZone 는 개체 배열 DateWithTimeZone 을 직렬화하고 역직렬화하는 다음 두 예제에서 사용됩니다. GitHub의 문서 리포지토리에서 Visual Basic, F#또는 C# 에서 이 문서의 전체 예제 집합에 대한 원본을 볼 수 있습니다.

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

public static void SaveDateWithTimeZone()
{
    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")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {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 serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDateWithTimeZone () =
    let dates = 
        [| DateWithTimeZone(DateTime(2014, 8, 9, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 15, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Pacific Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 22, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 28, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time") |]

    use fs = new FileStream(@".\Schedule.bin", FileMode.Create)
    let formatter = BinaryFormatter()
    try
        formatter.Serialize(fs, dates)
        // Display dates.
        for date in dates do
            let tz = date.TimeZone
            printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
    with :? SerializationException as e ->
        printfn $"Serialization failed. Reason: {e.Message}"

// 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
Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' 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 호출하여 역직렬화합니다.

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {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
let restoreDateWithTimeZone () =
    let filename = @".\Schedule.bin"
    if File.Exists filename then
        use fs = new FileStream(filename, FileMode.Open)

        let formatter = BinaryFormatter()
        try
            let dates = formatter.Deserialize fs :?> DateWithTimeZone []
            // Display dates.
            for date in dates do
                let tz = date.TimeZone
                printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
        with :? SerializationException as e ->
            printfn $"Deserialization failed. Reason: {e.Message}"
    else
        printfn "Unable to find file to deserialize."

// 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
Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' 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

DateTime 및 TimeSpan

TimeSpan 값 형식은 DateTime 시간 간격을 DateTime 나타내는 반면 시간 단위는 TimeSpan 인스턴트를 나타낸다는 점에서 다릅니다. 한 인스턴스를 DateTime 다른 인스턴스에서 빼서 둘 사이의 시간 간격을 TimeSpan 나타내는 개체를 가져올 수 있습니다. 또는 현재 DateTime 에 긍정 TimeSpan 을 추가하여 이후 날짜를 나타내는 값을 가져올 DateTime 수 있습니다.

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

허용 범위 내의 같음 비교

값에 대한 DateTime 같음 비교는 정확합니다. 즉, 같음으로 간주되려면 두 값을 동일한 수의 틱으로 표현해야 합니다. 이러한 정밀도는 종종 많은 애플리케이션에서 불필요하거나 정확하지 않습니다. 종종 개체가 거의 같은DateTime 테스트하려고 합니다.

다음 예제에서는 대략 동일한 DateTime 값을 비교하는 방법을 보여 줍니다. 같음으로 선언할 때 약간의 차이 여백을 허용합니다.

public 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 TestRoughlyEquals()
{
    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 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({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
let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
    let delta = 
        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
    
    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
    abs delta < windowInSeconds

let testRoughlyEquals () =
    let window = 10
    let window' = 10.
    let freq = 60 * 60 * 2 // 2 hours

    let d1 = DateTime.Now

    let d2 = d1.AddSeconds(2. * window')
    let d3 = d1.AddSeconds(-2. * window')
    let d4 = d1.AddSeconds(window' / 2.)
    let d5 = d1.AddSeconds(-window' / 2.)

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

    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"

    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
    printfn $"d1 ({d1}) ~= d9 ({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
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

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

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

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

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' 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

COM interop 고려 사항

DateTime 관리 되는 애플리케이션을 다시 전송한 다음 COM 애플리케이션에 전송 되는 값을 왕복 이라고 합니다. 그러나 DateTime 시간만 지정하는 값은 예상한 대로 왕복하지 않습니다.

오후 3시와 같은 시간만 왕복하는 경우 최종 날짜와 시간은 1899년 12월 30일입니다. 0001년 1월 1일 오후 3:00 오후 3:00 .NET Framework 및 COM은 시간만 지정된 경우 기본 날짜를 가정합니다. 그러나 COM 시스템은 1899년 12월 30일 C.E.의 기본 날짜를 가정하고 .NET Framework 기본 날짜인 0001년 1월 1일을 가정합니다.

.NET Framework COM으로 시간만 전달되면 시간을 COM에서 사용하는 형식으로 변환하는 특수 처리가 수행됩니다. COM에서 .NET Framework 시간만 전달되면 1899년 12월 30일 또는 그 이전에 합법적인 날짜와 시간이 손상되기 때문에 특별한 처리가 수행되지 않습니다. 날짜가 COM에서 왕복을 시작하는 경우 .NET Framework 및 COM은 날짜를 유지합니다.

.NET Framework 및 COM의 동작 버전임을 애플리케이션에 대 한 왕복 작업에는 DateTime 만 지정 하는 한 번, 애플리케이션을 수정 하거나 마지막에서 잘못 된 날짜를 무시 해야 합니다. DateTime 개체입니다.

생성자

DateTime(Int32, Int32, Int32)

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

DateTime(Int32, Int32, Int32, Calendar)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

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

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

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

DateTime(Int64)

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

DateTime(Int64, DateTimeKind)

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

필드

MaxValue

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

MinValue

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

UnixEpoch

이 상수 값은 그레고리오력의 1970년 1월 1일 00:00:00.0000000 UTC와 같습니다. UnixEpoch는 Unix 시간이 0인 시점을 정의합니다.

속성

Date

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

Day

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

DayOfWeek

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

DayOfYear

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

Hour

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

Kind

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

Microsecond

0에서 999 사이의 값으로 표현되는 마이크로초 구성 요소입니다.

Millisecond

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

Minute

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

Month

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

Nanosecond

0에서 900 사이의 값으로 표현된 나노초 구성 요소(100나노초 단위).

Now

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

Second

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

Ticks

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

TimeOfDay

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

Today

현재 날짜를 가져옵니다.

UtcNow

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

Year

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

메서드

Add(TimeSpan)

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

AddDays(Double)

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

AddHours(Double)

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

AddMicroseconds(Double)

지정된 수의 마이크로초가 이 인스턴스의 값에 추가되는 새 DateTime 값을 반환합니다.

AddMilliseconds(Double)

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

AddMinutes(Double)

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

AddMonths(Int32)

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

AddSeconds(Double)

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

AddTicks(Int64)

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

AddYears(Int32)

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

Compare(DateTime, DateTime)

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

CompareTo(DateTime)

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

CompareTo(Object)

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

DaysInMonth(Int32, Int32)

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

Equals(DateTime)

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

Equals(DateTime, DateTime)

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

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 표시하는 값을 반환합니다.

FromBinary(Int64)

64비트 이진 값을 역직렬화하고 직렬화된 원본 DateTime 개체를 다시 만듭니다.

FromFileTime(Int64)

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

FromFileTimeUtc(Int64)

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

FromOADate(Double)

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

GetDateTimeFormats()

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

GetDateTimeFormats(Char)

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

GetDateTimeFormats(Char, IFormatProvider)

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

GetDateTimeFormats(IFormatProvider)

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

GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.

GetTypeCode()

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

IsDaylightSavingTime()

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

IsLeapYear(Int32)

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

문자 범위를 값으로 구문 분석합니다.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 문자열 표현을 포함하는 메모리 범위를 동등한 해당 DateTime으로 변환합니다.

Parse(String)

현재 문화권의 규칙을 사용하여 날짜 및 시간의 DateTime 문자열 표현을 해당하는 값으로 변환합니다.

Parse(String, IFormatProvider)

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

Parse(String, IFormatProvider, DateTimeStyles)

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

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

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

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

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

ParseExact(String, String, IFormatProvider)

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

ParseExact(String, String, IFormatProvider, DateTimeStyles)

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

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

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

SpecifyKind(DateTime, DateTimeKind)

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

Subtract(DateTime)

이 인스턴스의 값에서 지정된 날짜와 시간을 뺀 새 TimeSpan을 반환합니다.

Subtract(TimeSpan)

이 인스턴스의 값에서 지정된 기간을 뺀 새 DateTime을 반환합니다.

ToBinary()

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

ToFileTime()

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

ToFileTimeUtc()

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

ToLocalTime()

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

ToLongDateString()

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

ToLongTimeString()

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

ToOADate()

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

ToShortDateString()

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

ToShortTimeString()

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

ToString()

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

ToString(IFormatProvider)

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

ToString(String)

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

ToString(String, IFormatProvider)

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

ToUniversalTime()

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

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

현재 datetime 인스턴스 값의 형식을 제공된 문자 범위로 지정하려고 시도합니다.

TryParse(ReadOnlySpan<Char>, DateTime)

날짜와 시간에 대한 지정된 문자 범위를 해당하는 DateTime(으)로 변환하고, 변환에 성공했는지를 나타내는 값을 반환합니다.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

문자 범위를 값으로 구문 분석하려고 시도합니다.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

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

TryParse(String, DateTime)

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

TryParse(String, IFormatProvider, DateTime)

문자열을 값으로 구문 분석하려고 시도합니다.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

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

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

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

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

날짜와 시간에 대한 지정된 문자 범위를 해당하는 DateTime(으)로 변환하고, 변환에 성공했는지를 나타내는 값을 반환합니다.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

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

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

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

연산자

Addition(DateTime, TimeSpan)

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

Equality(DateTime, DateTime)

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

GreaterThan(DateTime, DateTime)

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

GreaterThanOrEqual(DateTime, DateTime)

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

Inequality(DateTime, DateTime)

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

LessThan(DateTime, DateTime)

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

LessThanOrEqual(DateTime, DateTime)

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

Subtraction(DateTime, DateTime)

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

Subtraction(DateTime, TimeSpan)

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

명시적 인터페이스 구현

IComparable.CompareTo(Object)

현재 인스턴스와 동일한 형식의 다른 개체를 비교하고 정렬 순서에서 현재 인스턴스의 위치가 다른 개체보다 앞인지, 뒤인지 또는 동일한지를 나타내는 정수를 반환합니다.

IConvertible.GetTypeCode()

이 인스턴스에 대한 TypeCode를 반환합니다.

IConvertible.ToBoolean(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToByte(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToChar(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToDateTime(IFormatProvider)

현재 DateTime 개체를 반환합니다.

IConvertible.ToDecimal(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToDouble(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToInt16(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToInt32(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToInt64(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToSByte(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToSingle(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToType(Type, IFormatProvider)

현재 DateTime 개체를 지정된 형식의 개체로 변환합니다.

IConvertible.ToUInt16(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToUInt32(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToUInt64(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

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

적용 대상

스레드 보안

이 형식의 모든 멤버는 스레드로부터 안전합니다. 인스턴스 상태를 수정하는 것처럼 보이는 멤버는 실제로 새 값으로 초기화된 새 인스턴스를 반환합니다. 다른 형식과 마찬가지로 이 형식의 인스턴스를 포함하는 공유 변수에 대한 읽기 및 쓰기는 스레드 안전을 보장하기 위해 잠금으로 보호되어야 합니다.

추가 정보