DateTime DateTime DateTime DateTime Struct

정의

일반적으로 날짜와 시간으로 표시된 시간을 나타냅니다.Represents an instant in time, typically expressed as a date and time of day.

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

설명

중요

JapaneseCalendarJapaneseLunisolarCalendar의 새로운 세대가 2019년 5월 1일에 시작합니다.A new era in the JapaneseCalendar and JapaneseLunisolarCalendar begins on May 1, 2019. 이번 변경 내용은 달력을 사용하는 모든 애플리케이션에 영향을 줍니다.This change affects all applications that use these calendars. 자세한 내용 및 현재 애플리케이션이 영향을 받는지 확인하는 방법은 .NET에서 일본식 달력의 새로운 세대 처리를 참조하세요.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Windows 시스템에서 애플리케이션을 테스트하여 세대 변화에 대한 준비 상태를 확인하는 방법은 일본어 세대 변경을 위한 애플리케이션 준비를 참조하세요.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change.

참고

이 문서의 C# 예제는 Try.NET 인라인 코드 러너 및 놀이터에서 실행됩니다.The C# examples in this article run in the Try.NET inline code runner and playground. 대화형 창에서 예제를 실행하려면 실행 버튼을 선택합니다.Select the Run button to run an example in an interactive window. 코드를 실행하면 실행을 다시 선택하여 코드를 수정하고 수정된 코드를 실행할 수 있습니다.Once you execute the code, you can modify it and run the modified code by selecting Run again. 수정된 코드는 대화형 창에서 실행되거나, 컴파일이 실패하면 대화형 창에 모든 C# 컴파일러 오류 메시지가 표시됩니다.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Try.NET 인라인 코드 러너와 플레이그라운드의 현지 표준 시간대는 협정 세계시(또는 UTC)입니다.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. 이는 DateTime, DateTimeOffsetTimeZoneInfo 형식과 이러한 형식의 멤버를 보여주는 예제의 동작 및 출력에 영향을 줄 수 있습니다.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

이 문서에서는 사용 하는 몇 가지 예는 DateTime 형식:This article includes several examples that use the DateTime type:

초기화 예제Initialization Examples

서식 지정 DateTime 문자열로 개체Formatting DateTime objects as strings

문자열을 구문 분석 DateTime 개체Parsing strings as DateTime objects

DateTime 해결 방법DateTime resolution

문화권 및 달력Culture and calendars

지속성Persistence

이 섹션의 여러 일반적인 용도 대 한 항목이 포함 된 DateTime 구조체:This section contains topics for many common uses of the DateTime struct:

DateTime 값 형식을 날짜를 나타내고 서 기 9999 년 12 월 31 일 까지의 값을 가진 00시: 00 (자정)에서 1 월 1 일에서 0001 서 기 (Common Era) 오후 11시 59분: 59를 통해 시간The DateTime value type represents dates and times with values ranging from 00:00:00 (midnight), January 1, 0001 Anno Domini (Common Era) through 11:59:59 P.M., December 31, 9999 A.D. (C.E.) 에 해당 합니다.(C.E.) in the Gregorian calendar.

시간 값은 틱을 호출 하는 100 나노초 단위로 측정 됩니다.Time values are measured in 100-nanosecond units called ticks. 특정 날짜 자정 12:00 서 기 0001 년 1 월 1 일 이후 틱 수는A particular date is the number of ticks since 12:00 midnight, January 1, 0001 A.D. (C.E.) 에 GregorianCalendar 달력입니다.(C.E.) in the GregorianCalendar calendar. 윤 초에 의해 추가 된 틱 수에서 제외 됩니다.The number excludes ticks that would be added by leap seconds. 예를 들어 31241376000000000l 틱 값 12시: 00 자정 0100 월 01, 금요일 날짜를 나타냅니다.For example, a ticks value of 31241376000000000L represents the date Friday, January 01, 0100 12:00:00 midnight. DateTime 값은 항상 명시적의 컨텍스트 또는 기본 달력으로 표현 됩니다.A DateTime value is always expressed in the context of an explicit or default calendar.

참고

작업 하는 경우 틱 값을 사용 하 여 일부 다른 시간 간격을 분 또는 초 등 변환할을 사용 해야 합니다 TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, 또는 TimeSpan.TicksPerMillisecond 변환을 수행 하는 상수입니다.If you are working with a ticks value that you want to convert to some other time interval, such as minutes or seconds, you should use the TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, or TimeSpan.TicksPerMillisecond constant to perform the conversion. 예를 들어 시간 (초) 수를 추가 하려면 틱의 지정 된 번호로 표시 합니다 Second 구성 요소를 DateTime 값 식을 사용할 수 있습니다 dateValue.Second + nTicks/Timespan.TicksPerSecond합니다.For example, to add the number of seconds represented by a specified number of ticks to the Second component of a DateTime value, you can use the expression dateValue.Second + nTicks/Timespan.TicksPerSecond.

이 문서에서 예제의 전체 집합에 대 한 소스에서 볼 수 있습니다 Visual Basic 또는 C# GitHub의 docs 리포지토리에서 합니다.You can view the source for the entire set of examples from this article in either Visual Basic or C# from the docs repository on GitHub.

참고

대안을를 DateTime 는 특히 표준 시간대 날짜 및 시간 값을 사용 하 여 작업에 대 한 구조는 DateTimeOffset 구조입니다.An alternative to the DateTime structure for working with date and time values in particular time zones is the DateTimeOffset structure. 합니다 DateTimeOffset 개인의 날짜 및 시간 정보를 저장 하는 구조 DateTime 필드와는 해당 날짜와 시간 (분) 개인에서 UTC 다릅니다 Int16 필드입니다.The DateTimeOffset structure stores date and time information in a private DateTime field and the number of minutes by which that date and time differs from UTC in a private Int16 field. 이 수 있도록를 DateTimeOffset 반면 특정 표준 시간대의 시간을 반영 하도록 값을 DateTime 값은만 UTC 및 현지 표준 시간대의 시간에 명확 하 게 반영할 수 있습니다.This makes it possible for a DateTimeOffset value to reflect the time in a particular time zone, whereas a DateTime value can unambiguously reflect only UTC and the local time zone's time. 사용 하는 경우에 대 한 설명은 합니다 DateTime 구조 또는 DateTimeOffset 날짜 및 시간 값을 사용 하 여 작업 하는 경우 구조체를 참조 하십시오 Choosing Between DateTime, DateTimeOffset, TimeSpan 및 timezoneinfo 중합니다.For a discussion about when to use the DateTime structure or the DateTimeOffset structure when working with date and time values, see Choosing Between DateTime, DateTimeOffset, TimeSpan, and TimeZoneInfo.

DateTime 개체를 초기화합니다.Initializing a DateTime object

새 초기 값을 할당할 수 있습니다 DateTime 다양 한 값:You can assign an initial value to a new DateTime value in many different ways:

  • 값에 대 한 인수를 지정할 하나는 생성자를 호출 하거나 암시적 기본 생성자를 사용 합니다.Calling a constructor, either one where you specify arguments for values, or use the implicit default constructor.
  • 할당을 DateTime 속성 또는 메서드의 반환 값입니다.Assigning a DateTime to the return value of a property or method.
  • 구문 분석을 DateTime 값을 해당 문자열 표현입니다.Parsing a DateTime value from its string representation.
  • Visual Basic 관련 언어 기능을 사용 하 여 인스턴스화하는 DateTime합니다.Using Visual Basic-specific language features to instantiate a DateTime.

다음 코드 조각은 각 사례를 보여 줍니다.The following code snippets show examples of each:

생성자를 호출 합니다.Invoke Constructors

호출의 오버 로드 중 하나는 DateTime 날짜 및 시간 값 (예: 연도, 월 및 일 또는 틱 수)의 요소를 지정 하는 생성자입니다.You call any of the overloads of the DateTime constructor that specify elements of the date and time value (such as the year, month, and day, or the number of ticks). 다음 코드에서는 사용 하 여 특정 날짜를 DateTime 연도, 월, 일, 시간, 분 및 초를 지정 하는 생성자입니다.The following code creates a specific date using the DateTime constructor specifying the year, month, day, hour, minute, and second.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

호출 하는 DateTime 하려는 경우 구조체의 암시적 기본 생성자는 DateTime 기본값으로 초기화 합니다.You invoke the DateTime structure's implicit default constructor when you want a DateTime initialized to its default value. (값 형식의 암시적 기본 생성자에 대 한 내용은 참조 하세요 값 형식.) 일부 컴파일러에서는 선언도 지원는 DateTime 명시적으로 값을 할당 하지 않고 값입니다.(For details on the implicit default constructor of a value type, see Value Types.) Some compilers also support declaring a DateTime value without explicitly assigning a value to it. 기본 값도는 명시적 초기화 하지 않고 값을 만들면 발생 합니다.Creating a value without an explicit initialization also results in the default value. 다음 예제는 DateTime C# 및 Visual Basic의 경우 암시적 기본 생성자와 DateTime Visual Basic의 할당 되지 않은 선언 합니다.The following example illustrates the DateTime implicit default constructor in C# and Visual Basic, as well as a DateTime declaration without assignment in Visual Basic.

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

계산 된 값을 할당합니다.Assigning a computed value

할당할 수는 DateTime 속성 또는 메서드에서 반환 된 날짜 및 시간 값 개체입니다.You can assign the DateTime object a date and time value returned by a property or method. 다음 예에서는 현재 날짜 및 시간을 현재 utc (협정 세계시) 날짜 및 시간과 현재 날짜를 할당 세 개의 새 DateTime 변수입니다.The following example assigns the current date and time, the current Coordinated Universal Time (UTC) date and time, and the current date to three new DateTime variables.

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;

날짜/시간을 나타내는 문자열을 구문 분석Parsing a string that represents a DateTime

합니다 Parse, ParseExactTryParse, 및 TryParseExact 메서드는 모두 해당 날짜 및 시간 값을 문자열로 변환 합니다.The Parse, ParseExact, TryParse, and TryParseExact methods all convert a string to its equivalent date and time value. 다음 예에서는 합니다 ParseParseExact 문자열을 구문 분석 하 고 변환 하는 메서드를 DateTime 값입니다.The following examples use the Parse and ParseExact methods to parse a string and convert it to a DateTime value. 두 번째 형식에서 지원 되는 형태를 사용 합니다 ISO 8601 나타내는 날짜 및 시간 문자열 형식에 대 한 표준입니다.The second format uses a form supported by the ISO 8601 standard for a representing date and time in string format. 웹 서비스에서 날짜 정보를 전송 하려면이 표준 표현은 자주 사용 됩니다.This standard representation is often used to transfer date information in web services.

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)

string dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
string iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

TryParse 하 고 TryParseExact 메서드는 문자열에 대 한 유효한 표현 인지 여부를 나타내는 DateTime 값 및 경우에 변환을 수행 합니다.The TryParse and TryParseExact methods indicate whether a string is a valid representation of a DateTime value and, if it is, performs the conversion.

Visual Basic에 대 한 언어별 구문Language-specific syntax for Visual Basic

다음 Visual Basic 문은 초기화 새 DateTime 값입니다.The following Visual Basic statement initializes a new DateTime value.

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

DateTime 값과 해당 문자열 표현DateTime values and their string representations

내부적으로 모든 DateTime 값 (100 나노초 간격의 수) 0001 년 1 월 1 일 12시: 00 자정 이후 경과 된 틱 수로 표현 됩니다.Internally, all DateTime values are represented as the number of ticks (the number of 100-nanosecond intervals) that have elapsed since 12:00:00 midnight, January 1, 0001. 실제 DateTime 값은 해당 값이 표시 될 때 나타나는 방법과 무관 합니다.The actual DateTime value is independent of the way in which that value appears when displayed. 모양의 DateTime 값을 해당 문자열 표현으로 변환 하는 서식 지정 작업의 결과 값입니다.The appearance of a DateTime value is the result of a formatting operation that converts a value to its string representation.

날짜 및 시간 값의 모양을 문화권, 국제 표준, 애플리케이션 요구 사항 및 개인 기본 설정에 따라 달라 집니다.The appearance of date and time values is dependent on culture, international standards, application requirements, and personal preference. 합니다 DateTime 오버 로드를 통해 날짜 및 시간 값 서식 지정에 대 한 유연성을 제공 하는 구조 ToString합니다.The DateTime structure offers flexibility in formatting date and time values through overloads of ToString. 기본 DateTime.ToString() 메서드가 현재 문화권의 간단한 날짜 및 긴 시간 패턴을 사용 하 여 날짜 및 시간 값의 문자열 표현을 반환 합니다.The default DateTime.ToString() method returns the string representation of a date and time value using the current culture's short date and long time pattern. 다음 예제에서는 기본 DateTime.ToString() 메서드.The following example uses the default DateTime.ToString() method. 날짜 및 시간을 현재 문화권의 짧은 날짜 및 긴 시간 패턴을 사용 하 여 표시 됩니다.It displays the date and time using the short date and long time pattern for the current culture. EN-US 문화권은 예제를 실행 하는 컴퓨터의 현재 문화권입니다.The en-US culture is the current culture on the computer on which the example was run.

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

클라이언트에서 서로 다른 문화권의 서버 수 있는 웹 시나리오를 지원 하도록 특정 문화권에서 날짜 형식을 지정 해야 합니다.You may need to format dates in a specific culture to support web scenarios where the server may be in a different culture from the client. 사용 하 여 문화권을 지정 합니다 DateTime.ToString(IFormatProvider) 메서드를 특정 문화권의 간단한 날짜 및 긴 시간 표현을 만듭니다.You specify the culture using the DateTime.ToString(IFormatProvider) method to create the short date and long time representation in a specific culture. 다음 예제에서는 DateTime.ToString(IFormatProvider) 메서드 및 간단한 날짜 및 긴 시간 패턴을 사용 하 여 FR-FR 문화권에 대 한 시간을 날짜를 표시 합니다.The following example uses the DateTime.ToString(IFormatProvider) method to display the date and time using the short date and long time pattern for the fr-FR culture.

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

다른 애플리케이션에는 다양 한 문자열 표현의 날짜 필요할 수 있습니다.Other applications may require different string representations of a date. DateTime.ToString(String) 메서드는 현재 문화권의 서식 규칙을 사용 하 여 표준 또는 사용자 지정 형식 지정자에 의해 정의 된 문자열 표현을 반환 합니다.The DateTime.ToString(String) method returns the string representation defined by a standard or custom format specifier using the formatting conventions of the current culture. 다음 예제에서는 DateTime.ToString(String) 문화권의 전체 날짜 및 시간 패턴을 EN-US를 표시 하는 메서드를 사용 하면 예제를 실행 하는 컴퓨터의 현재 문화권입니다.The following example uses the DateTime.ToString(String) method to display the full date and time pattern for the en-US culture, the current culture on the computer on which the example was run.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(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) 메서드.Finally, you can specify both the culture and the format using the DateTime.ToString(String, IFormatProvider) method. 다음 예제에서는 DateTime.ToString(String, IFormatProvider) 전체 날짜 및 시간 패턴 FR-FR 문화권을 표시 하는 방법입니다.The following example uses the DateTime.ToString(String, IFormatProvider) method to display the full date and time pattern for the fr-FR culture.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
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) 오버 로드 사용할 수도 있습니다는 사용자 지정 형식 문자열을 사용 하 여 다른 형식을 지정 합니다.The DateTime.ToString(String) overload can also be used with a custom format string to specify other formats. 다음 예제에서는 사용 하 여 문자열 서식 지정 방법을 합니다 ISO 8601 종종 웹 서비스에 사용 되는 표준 형식입니다.The following example shows how to format a string using the ISO 8601 standard format often used for web services. Iso 8601 형식에 해당 하는 표준 형식 문자열을 없습니다.The Iso 8601 format does not have a corresponding standard format string.

[!code-csharp-interactiveSystem.DateTime.Formatting#5][!code-csharp-interactiveSystem.DateTime.Formatting#5]

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z

형식에 대 한 자세한 내용은 DateTime 값을 참조 하세요 표준 날짜 및 시간 형식 문자열 하 고 사용자 지정 날짜 및 시간 형식 문자열합니다.For more information about formatting DateTime values, see Standard Date and Time Format Strings and Custom Date and Time Format Strings.

문자열에서 날짜/시간 값을 구문 분석Parsing DateTime values from strings

날짜 및 시간의 문자열 표현을 변환 구문 분석을 DateTime 값입니다.Parsing converts the string representation of a date and time to a DateTime value. 일반적으로 날짜 및 시간 문자열 애플리케이션에 두 개의 서로 다른 사용:Typically, date and time strings have two different usages in applications:

  • 날짜 및 시간을 다양 한 형태를 사용 하 고 현재 문화권 이나 특정 문화권의 규칙을 반영 합니다.A date and time takes a variety of forms and reflects the conventions of either the current culture or a specific culture. 예를 들어, 애플리케이션 사용자에 해당 현재 문화권이 EN-US "2013 년 12 월 15" 또는 "2013 년 12 월 15 년"로 날짜 값을 입력 허용For example, an application allows a user whose current culture is en-US to input a date value as "12/15/2013" or "December 15, 2013". 사용자가 현재 문화권이 인 en-gb "2013/12/15" 또는 "15 2013 년 12 월."로 날짜 값을 입력 하려면It allows a user whose current culture is en-gb to input a date value as "15/12/2013" or "15 December 2013."

  • 날짜 및 시간을 미리 정의 된 형식으로 표시 됩니다.A date and time is represented in a predefined format. 예를 들어, 애플리케이션으로 "20130103" 앱이 실행 되는 culture와 독립적으로 날짜를 serialize 합니다.For example, an application serializes a date as "20130103" independently of the culture on which the app is running. 애플리케이션에 필요한 날짜는 현재 문화권의 간단한 날짜 형식으로 입력 합니다.An application may require dates be input in the current culture's short date format.

사용 된 Parse 또는 TryParse 문화권을 사용한 일반적인 날짜 및 시간 형식 중 하나에서 문자열을 변환 하는 메서드를 DateTime 값.You use the Parse or TryParse method to convert a string from one of the common date and time formats used by a culture to a DateTime value. 다음 예제에서는 사용 하는 방법을 보여 줍니다 TryParse 날짜 문자열에서 다른 culture 별 형식으로 변환 하는 DateTime 값입니다.The following example shows how you can use TryParse to convert date strings in different culture-specific formats to a DateTime value. 영어 (영국) 및 호출 현재 문화권을 변경 하 여 GetDateTimeFormats() 날짜 및 시간 문자열의 배열을 생성 하는 방법입니다.It changes the current culture to English (Great Britain) and calls the GetDateTimeFormats() method to generate an array of date and time strings. 그런 다음 배열의 각 요소에 전달 된 TryParse 메서드.It then passes each element in the array to the TryParse method. 예의 출력을 구문 분석 메서드에서 각 culture 별 날짜 및 시간 문자열을 변환할 수를 보여 줍니다.The output from the example shows the parsing method was able to successfully convert each of the culture-specific date and time strings.

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

DateTime date1 = new DateTime(2013, 6, 1, 12, 32, 30);
List<string> 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
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As DateTime = 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

사용 된 ParseExactTryParseExact 특정 형식 또는 형식으로 일치 해야 하는 문자열로 변환 하는 메서드를 DateTime 값.You use the ParseExact and TryParseExact methods to convert a string that must match a particular format or formats to a DateTime value. 구문 분석 메서드에서 매개 변수로 하나 이상의 날짜 및 시간 서식 문자열을 지정합니다.You specify one or more date and time format strings as a parameter to the parsing method. 다음 예제에서는 합니다 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) 메서드는 "yyyyMMdd" 형식 또는 "HHmmss" 형식으로 해야 하는 문자열을 변환할 DateTime 값입니다.The following example uses the TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) method to convert strings that must be either in a "yyyyMMdd" format or a "HHmmss" format to DateTime values.

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
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 표준 형식입니다.One common use for ParseExact is to convert a string representation from a web service, usually in ISO 8601 standard format. 다음 코드를 사용 하는 올바른 형식으로 문자열을 보여 줍니다.The following code shows the correct format string to use:

string iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", 
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{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}")

문자열을 구문 분석할 수 없으면, 합니다 ParseParseExact 메서드 예외를 throw 합니다.If a string cannot be parsed, the Parse and ParseExact methods throw an exception. TryParseTryParseExact 메서드는 반환을 Boolean 변환이 성공 또는 실패 여부를 나타내는 값입니다.The TryParse and TryParseExact methods return a Boolean value that indicates whether the conversion succeeded or failed. 사용 해야 합니다 TryParse 또는 TryParseExact 성능은 매우 중요 한 시나리오에서 메서드.You should use the TryParse or TryParseExact methods in scenarios where performance is important. 높은 실패율을 포함 하려는 경향이 있습니다 날짜 및 시간 문자열 구문 분석 작업 및 예외 처리 비용이 많이 듭니다.The parsing operation for date and time strings tends to have a high failure rate, and exception handling is expensive. 문자열은 사용자가 입력 하는 경우 이러한 메서드를 사용 또는 알 수 없는 소스에서 제공 될 예정입니다.Use these methods if strings are input by users or coming from an unknown source.

날짜 및 시간 값을 구문 분석 하는 방법에 대 한 자세한 내용은 참조 하세요. 구문 분석 하는 날짜 및 시간 문자열합니다.For more information about parsing date and time values, see Parsing Date and Time Strings.

날짜/시간 값DateTime values

시간 값에 대 한 설명은 DateTime 형식을 utc (협정 세계시) 표준을 사용 하 여를 종종 표현 됩니다.Descriptions of time values in the DateTime type are often expressed using the Coordinated Universal Time (UTC) standard. Coordinated Universal Time은 저명한 이름을 그리니치 표준시 (GMT).Coordinated Universal Time is the internationally recognized name for Greenwich Mean Time (GMT). Coordinated Universal Time은 UTC 원점 경도 0도에서 측정 되는 시간입니다.Coordinated Universal Time is the time as measured at zero degrees longitude, the UTC origin point. 일광 절약 시간 UTC에 해당 되지 않습니다.Daylight saving time is not applicable to UTC.

현지 시간을 특정 표준 시간대에 상대적입니다.Local time is relative to a particular time zone. 표준 시간대의 표준 시간대 오프셋 연관 됩니다.A time zone is associated with a time zone offset. 표준 시간대 오프셋이 UTC 시작 지점에서 시간 단위로 측정 된 표준 시간대의 치환 있습니다.A time zone offset is the displacement of the time zone measured in hours from the UTC origin point. 또한 현지 시간을 더하거나 뺍니다 시간 간격 조정을 일광 절약 시간을 필요에 따라 달라 집니다.In addition, local time is optionally affected by daylight saving time, which adds or subtracts a time interval adjustment. 현지 시간 UTC와 필요한 경우 일광 절약 시간 조정에 표준 시간대 오프셋을 추가 하 여 계산 됩니다.Local time is calculated by adding the time zone offset to UTC and adjusting for daylight saving time if necessary. UTC 시작 지점에서 표준 시간대 오프셋은 0입니다.The time zone offset at the UTC origin point is zero.

파일의 UTC 시간 계산, 비교 및 저장 날짜 및 시간에 적합합니다.UTC time is suitable for calculations, comparisons, and storing dates and time in files. 현지 시간 데스크톱 애플리케이션의 사용자 인터페이스에 표시 하기에 적합합니다.Local time is appropriate for display in user interfaces of desktop applications. 표준 시간대 인식 애플리케이션 (예: 여러 웹 애플리케이션)는 또한 다양 한 다른 표준 시간대를 사용 하 여 작업 해야 합니다.Time zone-aware applications (such as many Web applications) also need to work with a number of other time zones.

경우는 Kind 의 속성을 DateTime 개체가 DateTimeKind.Unspecified, 표시 된 시간이 현지 시간 또는 UTC 시간, 일부 다른 표준 시간대의 시간 인지 지정 되지 않습니다.If the Kind property of a DateTime object is DateTimeKind.Unspecified, it is unspecified whether the time represented is local time, UTC time, or a time in some other time zone.

날짜/시간 확인DateTime resolution

참고

날짜 및 시간 산술 연산을 수행 하는 대신 DateTime 값 경과 시간 측정을 사용할 수는 Stopwatch 클래스입니다.As an alternative to performing date and time arithmetic on DateTime values to measure elapsed time, you can use the Stopwatch class.

Ticks 속성이 하나 천만 분의 초 단위로 날짜 및 시간 값 표현 합니다.The Ticks property expresses date and time values in units of one ten-millionth of a second. Millisecond 속성 날짜 및 시간 값에서 1/1000 초를 반환 합니다.The Millisecond property returns the thousandths of a second in a date and time value. 반복 된 호출을 사용 하 여 DateTime.Now 경과 된 시간을 측정 하는 속성은 시스템 클록에 따라 달라 집니다.Using repeated calls to the DateTime.Now property to measure elapsed time is dependent on the system clock. Windows 7 및 Windows 8 시스템에서 시스템 클록에 약 15 시간 (밀리초)을 확인 합니다.The system clock on Windows 7 and Windows 8 systems has a resolution of approximately 15 milliseconds. 이 해결 방법은 짧은 시간 간격 100 밀리초를 보다 적은 영향을 줍니다.This resolution affects small time intervals less than 100 milliseconds.

다음 예에서는 현재 날짜 및 시간 값의 시스템 클록의 해상도에 대 한 종속성을 보여 줍니다.The following example illustrates the dependence of current date and time values on the resolution of the system clock. 예제에서는 외부 루프를 20 회 반복 및 외부 루프를 지연 하는 데 사용 되는 내부 루프입니다.In the example, an outer loop repeats 20 times, and an inner loop serves to delay the outer loop. 외부 루프 카운터의 값은 10에 대 한 호출을 Thread.Sleep 메서드 5 밀리초 지연을 소개 합니다.If the value of the outer loop counter is 10, a call to the Thread.Sleep method introduces a five-millisecond delay. 다음 예제에서는에서 반환 하는 시간 (밀리초)의 수를 DateTime.Now.Milliseconds 를 호출한 후에 속성 변경 내용을 Thread.Sleep합니다.The following example shows the number of milliseconds returned by the DateTime.Now.Milliseconds property changes only after the call to Thread.Sleep.

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

사용 하 여 계산을 DateTime 구조체와 같은 Add 또는 Subtract, 구조체의 값을 수정 하지는 않습니다.A calculation using a DateTime structure, such as Add or Subtract, does not modify the value of the structure. 대신 계산 반환 새 DateTime 계산의 결과 값을 갖는 구조체입니다.Instead, the calculation returns a new DateTime structure whose value is the result of the calculation.

변환 작업 (예:: UTC와 현지 시간 또는 시간대 사이)의 표준 시간대 간에 일광 절약 시간을 계정으로 걸리지만 산술 및 비교 작업 하지 않습니다.Conversion operations between time zones (such as between UTC and local time, or between one time zone and another) take daylight saving time into account, but arithmetic and comparison operations do not.

DateTime 구조 자체는 다른 시간대에서 변환에 대 한 제한 된 지원을 제공 합니다.The DateTime structure itself offers limited support for converting from one time zone to another. 사용할 수는 ToLocalTime 현지 시간을 UTC로 변환 하는 방법에 사용할 수는 ToUniversalTime 현지 시간에서 UTC로 변환 하는 방법입니다.You can use the ToLocalTime method to convert UTC to local time, or you can use the ToUniversalTime method to convert from local time to UTC. 그러나 표준 시간대 변환 메서드의 전체 집합은에서 사용할 수 있는는 TimeZoneInfo 클래스입니다.However, a full set of time zone conversion methods is available in the TimeZoneInfo class. 이러한 메서드를 사용 하 여 다른 표준 시간대의 시간에 전 세계의 표준 시간대 중 하나로 변환할 수 있습니다.You convert the time in any one of the world's time zones to the time in any other time zone using these methods.

계산 및 비교 DateTime 개체는 개체가 동일한 표준 시간대의 시간을 나타내는 경우에 의미가 있습니다.Calculations and comparisons of DateTime objects are meaningful only if the objects represent times in the same time zone. 사용할 수는 TimeZoneInfo 를 나타내는 개체를 DateTime 값의 시간 영역을 두는 느슨하게 결합 되어 있지만.You can use a TimeZoneInfo object to represent a DateTime value's time zone, although the two are loosely coupled. DateTime 개체에 해당 날짜 및 시간 값의 표준 시간대를 나타내는 개체를 반환 하는 속성이 없습니다.A DateTime object does not have a property that returns an object that represents that date and time value's time zone. 합니다 Kind 속성 표시 하는 경우는 DateTime UTC를 현지 시간을 나타내거나 지정 되지 않았습니다.The Kind property indicates if a DateTime represents UTC, local time, or is unspecified. 표준 시간대 인식 애플리케이션에서 사용 해야 합니다는 표준 시간대를 확인 하는 일부 외부 메커니즘을 DateTime 개체가 만들어진 합니다.In a time zone-aware application, you must rely on some external mechanism to determine the time zone in which a DateTime object was created. 둘 다를 래핑하는 구조체를 사용할 수 있습니다 합니다 DateTime 값 및 TimeZoneInfo 나타내는 개체를 DateTime 값의 표준 시간대입니다.You could use a structure that wraps both the DateTime value and the TimeZoneInfo object that represents the DateTime value's time zone. UTC를 사용 하 여 계산 및 비교에 대 한 자세한 내용은 DateTime 값을 참조 하세요 날짜 및 시간 산술 연산 수행합니다.For details on using UTC in calculations and comparisons with DateTime values, see Performing Arithmetic Operations with Dates and Times.

DateTime 멤버 암시적으로 해당 작업을 수행 하려면 일반 달력을 사용 합니다.Each DateTime member implicitly uses the Gregorian calendar to perform its operation. 예외는 암시적으로 일정을 지정 하는 방법입니다.Exceptions are methods that implicitly specify a calendar. 파생 된 매개 변수를 사용 하 여 메서드 및 달력을 지정 하는 생성자를 포함 하는 이러한 IFormatProvider와 같은 System.Globalization.DateTimeFormatInfo합니다.These include constructors that specify a calendar, and methods with a parameter derived from IFormatProvider, such as System.Globalization.DateTimeFormatInfo.

작업의 멤버는 DateTime 형식 윤년 및 월의 일 수와 같은 정보를 고려 합니다.Operations by members of the DateTime type take into account details such as leap years and the number of days in a month.

날짜/시간 값 및 달력DateTime values and calendars

.NET Framework 클래스 라이브러리는 다양 한 달력 클래스에서 파생 되는 모든 포함 된 Calendar 클래스입니다.The .NET Framework Class Library includes a number of calendar classes, all of which are derived from the Calendar class. 다음 창이 여기에 포함됩니다.They are:

중요

JapaneseCalendarJapaneseLunisolarCalendar의 새로운 세대가 2019년 5월 1일에 시작합니다.A new era in the JapaneseCalendar and JapaneseLunisolarCalendar begins on May 1, 2019. 이번 변경 내용은 달력을 사용하는 모든 애플리케이션에 영향을 줍니다.This change affects all applications that use these calendars. 자세한 내용 및 현재 애플리케이션이 영향을 받는지 확인하는 방법은 .NET에서 일본식 달력의 새로운 세대 처리를 참조하세요.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Windows 시스템에서 애플리케이션을 테스트하여 세대 변화에 대한 준비 상태를 확인하는 방법은 일본어 세대 변경을 위한 애플리케이션 준비를 참조하세요.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change.

각 문화권에 해당 읽기 전용으로 정의 된 기본 달력을 사용 하 여 CultureInfo.Calendar 속성입니다.Each culture uses a default calendar defined by its read-only CultureInfo.Calendar property. 각 문화권의 읽기 전용으로 정의 하는 하나 이상의 달력을 지원할 수 있습니다 CultureInfo.OptionalCalendars 속성입니다.Each culture may support one or more calendars defined by its read-only CultureInfo.OptionalCalendars property. 현재 사용 하는 특정 달력 CultureInfo 하 여 개체가 정의 된 해당 DateTimeFormatInfo.Calendar 속성입니다.The calendar currently used by a specific CultureInfo object is defined by its DateTimeFormatInfo.Calendar property. 있는 달력 중 하나 여야 합니다 CultureInfo.OptionalCalendars 배열입니다.It must be one of the calendars found in the CultureInfo.OptionalCalendars array.

문화권의 현재 달력은 해당 문화권에 대 한 모든 서식 지정 작업에 사용 됩니다.A culture's current calendar is used in all formatting operations for that culture. 예를 들어, 태국 불교식 문화권의 기본 달력은 요소로 표시 되는 태국 불교식 달력을 ThaiBuddhistCalendar 클래스입니다.For example, the default calendar of the Thai Buddhist culture is the Thai Buddhist Era calendar, which is represented by the ThaiBuddhistCalendar class. 경우는 CultureInfo 태국 불교식 문화권을 나타내는 개체를 날짜 및 시간 형식 지정 작업 사용, 태국 불교식 달력 기본적으로 사용 됩니다.When a CultureInfo object that represents the Thai Buddhist culture is used in a date and time formatting operation, the Thai Buddhist Era calendar is used by default. 경우에 양력을 사용 되는 문화권의 DateTimeFormatInfo.Calendar 속성이 변경 되 면 다음 예제와 같이:The Gregorian calendar is used only if the culture's DateTimeFormatInfo.Calendar property is changed, as the following example shows:

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));
// Press "Run" to see the output
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

문화권의 현재 달력 다음 예와 같이 해당 문화권에 대 한 모든 구문 분석 작업에도 사용 됩니다.A culture's current calendar is also used in all parsing operations for that culture, as the following example shows.

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));
// Press "Run" to see the output
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 를 호출 하 여 특정 달력의 날짜 및 시간 요소 (연도, 월 및 일 수)를 사용 하 여 값을 DateTime 생성자 포함 하는 calendar 매개 변수 및 전달 된 Calendar해당 달력을 나타내는 개체입니다.You instantiate a DateTime value using the date and time elements (number of the year, month, and day) of a specific calendar by calling a DateTime constructor that includes a calendar parameter and passing it a Calendar object that represents that calendar. 다음 예에서는 날짜 및 시간 요소를 ThaiBuddhistCalendar 달력입니다.The following example uses the date and time elements from the ThaiBuddhistCalendar calendar.

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}");
// Press "Run" to see the output
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine("Thai Buddhist Era date: {0}", dat.ToString("d", thTH))
Console.WriteLine("Gregorian date:   {0:d}", dat)
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime 포함 하지 않는 생성자를 calendar 매개 변수는 날짜 및 시간 요소 그레고리오력의 단위로 표현 됩니다 하는 것으로 가정 합니다.DateTime constructors that do not include a calendar parameter assume that the date and time elements are expressed as units in the Gregorian calendar.

다른 모든 DateTime 속성 및 메서드 양력을 사용 합니다.All other DateTime properties and methods use the Gregorian calendar. 예를 들어 합니다 DateTime.Year 일반 달력의 연도 반환 하는 속성 및 DateTime.IsLeapYear(Int32) 가정 메서드를 year 매개 변수는 일반 달력의 연간 합니다.For example, the DateTime.Year property returns the year in the Gregorian calendar, and the DateTime.IsLeapYear(Int32) method assumes that the year parameter is a year in the Gregorian calendar. DateTime 양력을 사용 하는 멤버의 해당 멤버가 Calendar 특정 달력을 사용 하는 클래스입니다.Each DateTime member that uses the Gregorian calendar has a corresponding member of the Calendar class that uses a specific calendar. 예를 들어 합니다 Calendar.GetYear 메서드는 특정 달력의 연도 반환 합니다. 및 Calendar.IsLeapYear 해석 하는 메서드를 year 특정 달력의 연도 숫자 매개 변수.For example, the Calendar.GetYear method returns the year in a specific calendar, and the Calendar.IsLeapYear method interprets the year parameter as a year number in a specific calendar. 다음 예제에서는 둘 다를 DateTime 및 해당 멤버는 ThaiBuddhistCalendar 클래스입니다.The following example uses both the DateTime and the corresponding members of the ThaiBuddhistCalendar class.

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)}");
// Press "Run" to see the output
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: {0}", dat.ToString("d", thTH))
Console.WriteLine("Year: {0}", cal.GetYear(dat))
Console.WriteLine("Leap year: {0}", cal.IsLeapYear(cal.GetYear(dat)))
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine("Date: {0:d}", dat)
Console.WriteLine("Year: {0}", dat.Year)
Console.WriteLine("Leap year: {0}", DateTime.IsLeapYear(dat.Year))
' The example displays the following output:
'       Using the 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 양력에서 일 주를 반환 하는 속성입니다.The DateTime structure includes a DayOfWeek property that returns the day of the week in the Gregorian calendar. 해당 연도의 주 번호를 검색할 수 있는 멤버는 포함 되지 않습니다.It does not include a member that allows you to retrieve the week number of the year. 해당 연도의 주를 검색 하려면 개별 달력의 호출 Calendar.GetWeekOfYear 메서드.To retrieve the week of the year, call the individual calendar's Calendar.GetWeekOfYear method. 다음 예제에서 이에 대해 설명합니다.The following example provides an illustration.

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)}");
// Press "Run" to see the output
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: {0}", dat.ToString("d", thTH))
Console.WriteLine("Day of Week: {0}", thCalendar.GetDayOfWeek(dat))
Console.WriteLine("Week of year: {0}",
                thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay,
                                       DayOfWeek.Sunday))
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine("Date: {0:d}", dat)
Console.WriteLine("Day of Week: {0}", dat.DayOfWeek)
Console.WriteLine("Week of year: {0}",
                 greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay,
                                    DayOfWeek.Sunday))
' The example displays the following output:
'       Using the 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

날짜 및 달력에 대 한 자세한 내용은 참조 하세요. 달력을 사용 하 여 작업합니다.For more information on dates and calendars, see Working with Calendars.

날짜/시간 값 유지Persisting DateTime values

유지할 수 있습니다 DateTime 네 가지 방법으로 값:You can persist DateTime values in four ways:

복원 하는 루틴 확인 해야 합니다 DateTime 값 데이터가 손실 되거나 또는 선택 하는 방법에 관계 없이 예외를 throw 하지 않습니다.You must ensure that the routine that restores the DateTime values doesn't lose data or throw an exception regardless of which technique you choose. DateTime 값은 왕복 해야합니다.DateTime values should round-trip. 즉, 원래 값과 복원 동일 해야 합니다.That is, the original value and the restored value should be the same. 경우에 원래 DateTime 값 나타내는 단일 시간 인스턴스에, 복원 된 경우 시간의 동일한 순간을 식별 해야 합니다.And if the original DateTime value represents a single instant of time, it should identify the same moment of time when it's restored.

값을 문자열로 유지Persisting values as strings

성공적으로 복원 하려면 DateTime 유지 되는 값을 문자열로 같은이 규칙을 따릅니다.To successfully restore DateTime values that are persisted as strings, follow these rules:

  • 동일한 가정을 유지 한 경우 문자열을 복원 하면 culture 별 서식 지정 하는 방법에 대 한 합니다.Make the same assumptions about culture-specific formatting when you restore the string as when you persisted it. 현재 문화권이에 저장 된 시스템의 문화권에서 다른 시스템에서 문자열을 복원할 수 있도록 되도록 호출을 ToString 고정 문화권의 규칙을 사용 하 여 문자열을 저장 하는 오버 로드 합니다.To ensure that a string can be restored on a system whose current culture is different from the culture of the system it was saved on, call the ToString overload to save the string by using the conventions of the invariant culture. 호출 된 Parse(String, IFormatProvider, DateTimeStyles) 또는 TryParse(String, IFormatProvider, DateTimeStyles, DateTime) 고정 문화권의 규칙을 사용 하 여 문자열을 복원 하는 오버 로드 합니다.Call the Parse(String, IFormatProvider, DateTimeStyles) or TryParse(String, IFormatProvider, DateTimeStyles, DateTime) overload to restore the string by using the conventions of the invariant culture. 사용 하지 마십시오 합니다 ToString(), Parse(String), 또는 TryParse(String, DateTime) 현재 스레드 문화권의 규칙을 사용 하는 오버 로드 합니다.Never use the ToString(), Parse(String), or TryParse(String, DateTime) overloads, which use the conventions of the current thread culture.

  • 날짜 시간의 단일 순간을 나타내는 경우 시간 경우 복원 된 다른 표준 시간대에도 동일한 순간을 나타내는 것을 확인 합니다.If the date represents a single moment of time, ensure that it represents the same moment in time when it's restored, even on a different time zone. 변환 된 DateTime 저장 하기 전에 값을 Utc (협정 세계시).Convert the DateTime value to Coordinated Universal Time (UTC) before saving it. 표준 시간대 정보와 함께 값을 serialize 할 수 있습니다.You can also serialize the value along with time zone information. 이 방법에 대 한 자세한 내용은 참조 하세요. 직렬화 날짜/시간 및 표준 시간대 데이터입니다.For more information about this approach, see Serializing DateTime and time zone data.

유지 하는 경우 가장 일반적인 오류 DateTime 값을 문자열로 기본 또는 현재 문화권의 서식 규칙을 사용 하는 것입니다.The most common error made when persisting DateTime values as strings is to rely on the formatting conventions of the default or current culture. 문제가 현재 문화권 저장 및 문자열을 복원 하는 경우와 다른 경우 발생 합니다.Problems arise if the current culture is different when saving and restoring the strings. 다음 예제에서는 이러한 문제를 보여 줍니다.The following example illustrates these problems. 이 경우에 영어 (미국)는 현재 문화권의 서식 규칙을 사용 하는 5 날짜를 저장 합니다.It saves five dates using the formatting conventions of the current culture, which in this case is English (United States). 이 경우에 영어 (영국)는 다른 문화권의 서식 규칙을 사용 하 여 날짜를 복원 합니다.It restores the dates using the formatting conventions of a different culture, which in this case is English (Great Britain). 다른 두 문화권의 서식 규칙 이기 때문에 두 날짜를 복원할 수 없는 하 고 나머지 세 개의 날짜를 올바르게 해석 됩니다.Because the formatting conventions of the two cultures are different, two of the dates can't be restored, and the remaining three dates are interpreted incorrectly. 또한 원래 날짜 및 시간 값을 나타내는 단일 분 시간으로 복원 된 경우 표준 시간대 정보가 손실 되므로 시간이 올바르지 않습니다.Also, if the original date and time values represent single moments in time, the restored times are incorrect because time zone information is lost.

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 ? "|" : "");
    }
    StreamWriter 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...
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 다음이 단계를 성공적으로 수행 하는 값:To round-trip DateTime values successfully, follow these steps:

  1. 값은 시간의 단일 시점을 나타내는 경우 변환 현지 시간에서 UTC로 호출 하 여는 ToUniversalTime 메서드.If the values represent single moments of time, convert them from the local time to UTC by calling the ToUniversalTime method.
  2. 날짜를 호출 하 여 해당 문자열 표현으로 변환할 합니다 ToString(String, IFormatProvider) 또는 String.Format(IFormatProvider, String, Object[]) 오버 로드 합니다.Convert the dates to their string representations by calling the ToString(String, IFormatProvider) or String.Format(IFormatProvider, String, Object[]) overload. 고정 문화권의 서식 규칙을 사용 하 여 지정 하 여 CultureInfo.InvariantCulture 으로 provider 인수입니다.Use the formatting conventions of the invariant culture by specifying CultureInfo.InvariantCulture as the provider argument. "O" 또는 "R" 표준 서식 문자열을 사용 하 여 값을 왕복 해야 하는 것을 지정 합니다.Specify that the value should round-trip by using the "O" or "R" standard format string.

복원 된 지속형 DateTime 값 데이터 손실 없이 다음이 단계를 수행 합니다.To restore the persisted DateTime values without data loss, follow these steps:

  1. 호출 하 여 데이터를 구문 분석 합니다 ParseExact 또는 TryParseExact 오버 로드 합니다.Parse the data by calling the ParseExact or TryParseExact overload. 지정 CultureInfo.InvariantCulture 으로 provider 인수와 동일한 표준 서식 문자열 사용에 대 한 사용을 format 변환 하는 동안 인수입니다.Specify CultureInfo.InvariantCulture as the provider argument, and use the same standard format string you used for the format argument during conversion. 포함 된 DateTimeStyles.RoundtripKind 값을 styles 인수입니다.Include the DateTimeStyles.RoundtripKind value in the styles argument.
  2. 경우는 DateTime 값 호출 시간 내에 단일 순간을 나타내는 ToLocalTime UTC에서 현지 시간으로 구문 분석 된 날짜를 변환 하는 방법입니다.If the DateTime values represent single moments in time, call the ToLocalTime method to convert the parsed date from UTC to local time.

다음 예제에서는 고정 문화권 및 "O" 표준 서식 문자열을 사용 하 여 되도록 DateTime 값 저장 및 복원 시간 시스템, 문화권 또는 원본 및 대상 시스템의 표준 시간대에 관계 없이 동일한 순간을 나타냅니다.The following example uses the invariant culture and the "O" standard format string to ensure that DateTime values saved and restored represent the same moment in time regardless of the system, culture, or time zone of the source and target systems.

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 ? "|" : "");
    }
    StreamWriter 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...
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...

보존 값을 정수로Persisting values as integers

날짜 및 시간을 유지할 수 있습니다는 Int64 틱 수를 나타내는 값입니다.You can persist a date and time as an Int64 value that represents a number of ticks. 이 경우 시스템의 문화권을 고려해 야 할 없는 DateTime 값이 유지 및 복원 합니다.In this case, you don't have to consider the culture of the systems the DateTime values are persisted and restored on.

유지 하는 DateTime 정수는 값:To persist a DateTime value as an integer:

  • 경우는 DateTime 값이 시간에 단일 순간을 나타내는 호출 하 여 UTC로 변환 합니다 ToUniversalTime 메서드.If the DateTime values represent single moments in time, convert them to UTC by calling the ToUniversalTime method.
  • 가 나타내는 틱 수를 검색 합니다 DateTime 값에서 해당 Ticks 속성입니다.Retrieve the number of ticks represented by the DateTime value from its Ticks property.

복원 하는 DateTime 정수로 유지 된 값:To restore a DateTime value that has been persisted as an integer:

  1. DateTime 전달 하 여 개체를 Int64 값을 DateTime(Int64) 생성자입니다.Instantiate a new DateTime object by passing the Int64 value to the DateTime(Int64) constructor.
  2. 경우는 DateTime 값을 단일 시점을 나타내며, 변환 UTC에서 현지 시간으로 호출 하 여는 ToLocalTime 메서드.If the DateTime value represents a single moment in time, convert it from UTC to the local time by calling the ToLocalTime method.

다음 예제에서는 배열을 계속 되 면 DateTime 미국의 시스템에는 정수 값 표시합니다.The following example persists an array of DateTime values as integers on a system in the U.S. Pacific Time zone. UTC 표준 시간대의 시스템에 복원 합니다.It restores it on a system in the UTC zone. 정수를 포함 하는 파일에 포함 되어는 Int32 총 수를 나타내는 값 Int64 바로 뒤에 해당 하는 값입니다.The file that contains the integers includes an Int32 value that indicates the total number of Int64 values that immediately follow it.

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:");
    long[] ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    FileStream fs = new FileStream(filenameInts, FileMode.Create);
    BinaryWriter bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

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

private static void 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...
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...

날짜/시간 값을 직렬화합니다.Serializing DateTime values

유지할 수 있습니다 DateTime 값 스트림 또는 파일 및 다음 복원 하는 serialization을 통해 해당 deserialization을 통해.You can persist DateTime values through serialization to a stream or file, and then restore them through deserialization. DateTime 데이터가 일부 지정 된 개체 형식으로 직렬화 됩니다.DateTime data is serialized in some specified object format. 개체가 deserialize 될 때 복원 됩니다.The objects are restored when they are deserialized. 포맷터 또는 직렬 변환기와 같은 XmlSerializer 또는 BinaryFormatter, serialization 및 deserialization 프로세스를 처리 합니다.A formatter or serializer, such as XmlSerializer or BinaryFormatter, handles the process of serialization and deserialization. Serialization 및.NET Framework에서 지원 되는 serialization 형식에 대 한 자세한 내용은 참조 하세요. Serialization합니다.For more information about serialization and the types of serialization supported by the .NET Framework, see Serialization.

다음 예제에서는 합니다 XmlSerializer serialize 및 deserialize 하는 클래스 DateTime 값입니다.The following example uses the XmlSerializer class to serialize and deserialize DateTime values. 값은 21 세기의 모든 윤년 일을 나타냅니다.The values represent all leap year days in the twenty-first century. 이 예제에서는 현재 문화권이 영어 (영국) 인 시스템에서 실행 되는 경우 출력 결과를 나타냅니다.The output represents the result if the example is run on a system whose current culture is English (Great Britain). 역직렬화 한 때문에 DateTime 개체 자체 코드를 날짜 및 시간 형식의 문화적 차이 처리할 필요가 없습니다.Because you've deserialized the DateTime object itself, the code doesn't have to handle cultural differences in date and time formats.

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

    XmlSerializer serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(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 (FileStream 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
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

이전 예제에서는 시간 정보를 포함 하지 않습니다.The previous example doesn't include time information. 경우는 DateTime 현지 시간에서 UTC로 변환 호출 하 여 직렬화 하기 전에, 값 잠시 시간에서을 나타내고 현지 시간으로 표현 됩니다는 ToUniversalTime 메서드.If a DateTime value represents a moment in time and is expressed as a local time, convert it from local time to UTC before serializing it by calling the ToUniversalTime method. 후이 deserialize 할 변환할 UTC에서 현지 시간으로 호출 하 여는 ToLocalTime 메서드.After you deserialize it, convert it from UTC to local time by calling the ToLocalTime method. 다음 예제에서는 합니다 BinaryFormatter serialize 할 클래스 DateTime 미국에 있는 시스템의 데이터 태평양 표준 시간대 및 미국에 있는 시스템에서 deserialize 하는 데 중앙 표준 시간대입니다.The following example uses the BinaryFormatter class to serialize DateTime data on a system in the U.S. Pacific Standard Time zone and to deserialize it on a system in the U.S. Central Standard zone.

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) };
    FileStream fs = new FileStream(filenameBin, FileMode.Create);
    BinaryFormatter 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();
    DateTime[] 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...
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...

날짜/시간 및 표준 시간대 데이터를 직렬화 하는 작업Serializing DateTime and time zone data

이전 예제는 모두 있다고 가정 DateTime 값은 현지 시간으로 표현 됩니다.The previous examples all assumed that DateTime values are expressed as local times. 원본 시스템과 대상 시스템에서 시간의 동일한 순간을 반영 하므로 UTC와 현지 시간 사이의 값을 변환 하는 코드.The code converted the values between UTC and local time so they reflect the same moment in time on the source and target systems. DateTime 값에 local 이외의 표준 시간대와 UTC 시간에 또한 반영할 수 있습니다.DateTime values may also reflect moments in time in a time zone other than local and UTC. 때문에 합니다 DateTime 구조체가 표준 시간대 인식, 모두 serialize 해야 합니다 DateTime 값 및 TimeZoneInfo 해당 표준 시간대를 나타내는 개체입니다.Because the DateTime structure is not time zone-aware, you have to serialize both the DateTime value and the TimeZoneInfo object that represents its time zone. 해당 필드를 모두 포함 하는 형식 만들기는 DateTime 값 및 해당 표준 시간대입니다.Create a type whose fields include both the DateTime value and its time zone. 다음 예제에서는 정의 DateWithTimeZone 구조입니다.The following example defines a DateWithTimeZone structure.

using System;

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

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

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

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
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
            If timeZone Is Nothing Then
                tz = TimeZoneInfo.Local
            Else
                tz = timeZone
            End If
        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 개체입니다.The DateWithTimeZone structure is used in the next two examples, which serialize and deserialize an array of DateWithTimeZone objects. 이 문서에서 예제의 전체 집합에 대 한 소스에서 볼 수 있습니다 Visual Basic 또는 C# GitHub의 docs 리포지토리에서 합니다.You can view the source for the entire set of examples from this article in either Visual Basic or C# from the docs repository on GitHub.

사용 하 여는 DateWithTimeZone 구조, 날짜 및 시간 표준 시간대 정보와 함께 저장할 수 있습니다.By using the DateWithTimeZone structure, you can then persist date and time along with time zone information. 다음 예제에서는 합니다 BinaryFormatter 배열을 serialize 하는 클래스 DateWithTimeZone 개체입니다.The following example uses the BinaryFormatter class to serialize an array of DateWithTimeZone objects.

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")) };
    FileStream fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    BinaryFormatter formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{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
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 deserialize 하는 방법입니다.The following example then calls the BinaryFormatter.Deserialize method to deserialize it.

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;
    }

    BinaryFormatter formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ 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
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 vs입니다. TimeSpanDateTime vs. TimeSpan

DateTimeTimeSpan 하는 값 형식이 다를 DateTime 시점의 시간을 나타내는 반면를 TimeSpan 시간 간격을 나타냅니다.The DateTime and TimeSpan value types differ in that a DateTime represents an instant in time whereas a TimeSpan represents a time interval. 인스턴스 하나를 뺄 수 있습니다 DateTime 가져오려고 간에 TimeSpan 사이의 시간 간격을 나타내는 개체입니다.You can subtract one instance of DateTime from another to obtain a TimeSpan object that represents the time interval between them. 또는 양수를 추가할 수 있습니다 TimeSpan 현재 DateTime 가져오려고를 DateTime 이후 날짜를 나타내는 값입니다.Or you could add a positive TimeSpan to the current DateTime to obtain a DateTime value that represents a future date.

에 더하거나에서 시간 간격을 뺄 수는 DateTime 개체입니다.You can add or subtract a time interval from a DateTime object. 음수 또는 양수 시간 간격 수와 같은 틱을 단위로 표시할 수 있습니다 (초), 또는 TimeSpan 개체입니다.Time intervals can be negative or positive, and they can be expressed in units such as ticks, seconds, or as a TimeSpan object.

허용 오차 내에서 동일한 지 비교Comparing for equality within tolerance

에 대 한 같음 비교 DateTime 값은 정확 하 게 합니다.Equality comparisons for DateTime values are exact. 즉, 두 값 수가 같은 것으로 간주 되어야 하는 틱으로 표현 해야 합니다.That means two values must be expressed as the same number of ticks to be considered equal. 전체 자릿수는 종종 불필요 한도 많은 애플리케이션에 대 한 잘못 된 또는 합니다.That precision is often unecessary or even incorrect for many applications. 테스트 하려는 경우가 많습니다 DateTime 개체가 길쭉한합니다.Often, you want to test if DateTime objects are roughly equal.

다음 예제에서는 대략적으로 비교 하는 방법을 해당 DateTime 값입니다.The following example demonstrates how to compare roughly equivalent DateTime values. 같은 선언 하는 경우에 차이의 약간의 여백의 허용 합니다.It accepts a small margin of difference when declaring them equal.

[!code-csharpSystem.DateTime.Comparisons#1][!code-csharpSystem.DateTime.Comparisons#1]

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 고려 사항COM interop considerations

DateTime 관리 되는 응용 프로그램을 다시 전송한 다음 COM 응용 프로그램에 전송 되는 값을 왕복 이라고 합니다.A DateTime value that is transferred to a COM application, then is transferred back to a managed application, is said to round-trip. 그러나를 DateTime 한 번만 지정 하는 값 않습니다 예상할 수 있듯이 라운드트립 합니다.However, a DateTime value that specifies only a time does not round-trip as you might expect.

라운드트립 오후 3 시, 마지막 날짜 및 시간과 같은 시간만 서 기 1899 년 12 월 30 일 경우If you round-trip only a time, such as 3 P.M., the final date and time is December 30, 1899 C.E. 오후 3, 1 월 1 일 대신 서 기 0001at 3:00 P.M., instead of January, 1, 0001 C.E. 오후 3 시에at 3:00 P.M. .NET Framework 및 COM 기본 날짜 시간 동안에 지정 된 경우를 가정 합니다.The .NET Framework and COM assume a default date when only a time is specified. .NET Framework에는 서 기 0001 년 1 월 1 일을 기준 날짜로 가정 하는 동안 COM 시스템 기, 1899 년 12 월 30 일의 기본 날짜를 가정 하는 반면However, the COM system assumes a base date of December 30, 1899 C.E., while the .NET Framework assumes a base date of January, 1, 0001 C.E.

특수 한 처리에 사용 하는 com 형식으로 변환 하는 수행 시간 동안에.NET Framework에서 COM에 전달 되 면When only a time is passed from the .NET Framework to COM, special processing is performed that converts the time to the format used by COM. .NET Framework에 COM에서 한 번만 전달 되 면 올바른 날짜와 시간 이거나 그 이전인 1899 년 12 월 30 일 손상 될 수 있으므로 없습니다 특별 한 처리가 수행 됩니다.When only a time is passed from COM to the .NET Framework, no special processing is performed because that would corrupt legitimate dates and times on or before December 30, 1899. 해당 왕복 COM에서 시작 하는 날짜,.NET Framework 및 COM 날짜를 유지 합니다.If a date starts its round-trip from COM, the .NET Framework and COM preserve the date.

.NET Framework 및 COM의 동작 버전임을 애플리케이션에 대 한 왕복 작업에는 DateTime 만 지정 하는 한 번, 애플리케이션을 수정 하거나 마지막에서 잘못 된 날짜를 무시 해야 합니다. DateTime 개체입니다.The behavior of the .NET Framework and COM means that if your application round-trips a DateTime that only specifies a time, your application must remember to modify or ignore the erroneous date from the final DateTime object.

생성자

DateTime(Int64) DateTime(Int64) DateTime(Int64) DateTime(Int64)

DateTime 구조체의 새 인스턴스를 지정된 틱 수로 초기화합니다.Initializes a new instance of the DateTime structure to a specified number of ticks.

DateTime(Int64, DateTimeKind) DateTime(Int64, DateTimeKind) DateTime(Int64, DateTimeKind) DateTime(Int64, DateTimeKind)

DateTime 구조체의 새 인스턴스를 지정된 틱 수 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.Initializes a new instance of the DateTime structure to a specified number of ticks and to Coordinated Universal Time (UTC) or local time.

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

DateTime 구조체의 새 인스턴스를 특정 연도, 월 및 날짜로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, and day.

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

DateTime 구조체의 새 인스턴스를 지정된 달력의 지정된 연도, 월 및 날짜로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, and day for the specified calendar.

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

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 날짜, 시, 분 및 초로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, and second.

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

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, second, and Coordinated Universal Time (UTC) or local time.

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

DateTime 구조체의 새 인스턴스를 지정된 달력에서 지정된 연도, 월, 일, 시, 분 및 초로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, and second for the specified calendar.

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

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초 및 밀리초로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, second, and millisecond.

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

DateTime 구조체의 새 인스턴스를 지정된 연도, 월, 일, 시, 분, 초, 밀리초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, second, millisecond, and Coordinated Universal Time (UTC) or local time.

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

DateTime 구조체의 새 인스턴스를 지정된 달력에서 지정된 연도, 월, 일, 시, 분, 초 및 밀리초로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, second, and millisecond for the specified calendar.

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

DateTime 구조체의 새 인스턴스를 지정된 달력의 지정된 연도, 월, 일, 시, 분, 초, 밀리초 및 UTC(협정 세계시) 또는 현지 시간으로 초기화합니다.Initializes a new instance of the DateTime structure to the specified year, month, day, hour, minute, second, millisecond, and Coordinated Universal Time (UTC) or local time for the specified calendar.

필드

MaxValue MaxValue MaxValue MaxValue

DateTime의 최대값을 나타냅니다.Represents the largest possible value of DateTime. 이 필드는 읽기 전용입니다.This field is read-only.

MinValue MinValue MinValue MinValue

DateTime의 가능한 최소값을 나타냅니다.Represents the smallest possible value of DateTime. 이 필드는 읽기 전용입니다.This field is read-only.

UnixEpoch UnixEpoch UnixEpoch UnixEpoch

속성

Date Date Date Date

이 인스턴스의 날짜 구성 요소를 가져옵니다.Gets the date component of this instance.

Day Day Day Day

이 인스턴스가 나타내는 월의 일 수를 가져옵니다.Gets the day of the month represented by this instance.

DayOfWeek DayOfWeek DayOfWeek DayOfWeek

이 인스턴스가 나타내는 주의 일 수를 가져옵니다.Gets the day of the week represented by this instance.

DayOfYear DayOfYear DayOfYear DayOfYear

이 인스턴스가 나타내는 일 수를 정수로 가져옵니다.Gets the day of the year represented by this instance.

Hour Hour Hour Hour

이 인스턴스가 나타내는 날짜의 시간 구성 요소를 가져옵니다.Gets the hour component of the date represented by this instance.

Kind Kind Kind Kind

이 인스턴스에 표시된 시간이 현지 시간 또는 UTC(협정 세계시)를 기준으로 하는지 아니면 둘 중 어느 것도 기준으로 하지 않는지를 나타내는 값을 가져옵니다.Gets a value that indicates whether the time represented by this instance is based on local time, Coordinated Universal Time (UTC), or neither.

Millisecond Millisecond Millisecond Millisecond

이 인스턴스가 나타내는 날짜의 밀리초 구성 요소를 가져옵니다.Gets the milliseconds component of the date represented by this instance.

Minute Minute Minute Minute

이 인스턴스가 나타내는 날짜의 분 구성 요소를 가져옵니다.Gets the minute component of the date represented by this instance.

Month Month Month Month

이 인스턴스가 나타내는 날짜의 월 구성 요소를 가져옵니다.Gets the month component of the date represented by this instance.

Now Now Now Now

이 컴퓨터의 현재 날짜와 시간으로 설정되고 현지 시간으로 표시되는 DateTime 개체를 가져옵니다.Gets a DateTime object that is set to the current date and time on this computer, expressed as the local time.

Second Second Second Second

이 인스턴스가 나타내는 날짜의 초 구성 요소를 가져옵니다.Gets the seconds component of the date represented by this instance.

Ticks Ticks Ticks Ticks

이 인스턴스의 날짜와 시간을 나타내는 틱 수를 가져옵니다.Gets the number of ticks that represent the date and time of this instance.

TimeOfDay TimeOfDay TimeOfDay TimeOfDay

이 인스턴스에 대한 하루 중 시간을 가져옵니다.Gets the time of day for this instance.

Today Today Today Today

현재 날짜를 가져옵니다.Gets the current date.

UtcNow UtcNow UtcNow UtcNow

이 컴퓨터의 현재 날짜와 시간으로 설정되고 UTC(협정 세계시)로 표시되는 DateTime 개체를 가져옵니다.Gets a DateTime object that is set to the current date and time on this computer, expressed as the Coordinated Universal Time (UTC).

Year Year Year Year

이 인스턴스가 나타내는 날짜의 연도 구성 요소를 가져옵니다.Gets the year component of the date represented by this instance.

메서드

Add(TimeSpan) Add(TimeSpan) Add(TimeSpan) Add(TimeSpan)

지정된 DateTime의 값을 이 인스턴스의 값에 더하는 새 TimeSpan을 반환합니다.Returns a new DateTime that adds the value of the specified TimeSpan to the value of this instance.

AddDays(Double) AddDays(Double) AddDays(Double) AddDays(Double)

지정된 날짜 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of days to the value of this instance.

AddHours(Double) AddHours(Double) AddHours(Double) AddHours(Double)

지정된 시간 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of hours to the value of this instance.

AddMilliseconds(Double) AddMilliseconds(Double) AddMilliseconds(Double) AddMilliseconds(Double)

지정된 밀리초 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of milliseconds to the value of this instance.

AddMinutes(Double) AddMinutes(Double) AddMinutes(Double) AddMinutes(Double)

지정된 분 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of minutes to the value of this instance.

AddMonths(Int32) AddMonths(Int32) AddMonths(Int32) AddMonths(Int32)

지정된 월 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of months to the value of this instance.

AddSeconds(Double) AddSeconds(Double) AddSeconds(Double) AddSeconds(Double)

지정된 초 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of seconds to the value of this instance.

AddTicks(Int64) AddTicks(Int64) AddTicks(Int64) AddTicks(Int64)

지정된 틱 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of ticks to the value of this instance.

AddYears(Int32) AddYears(Int32) AddYears(Int32) AddYears(Int32)

지정된 연도 수를 이 인스턴스의 값에 더하는 새 DateTime을 반환합니다.Returns a new DateTime that adds the specified number of years to the value of this instance.

Compare(DateTime, DateTime) Compare(DateTime, DateTime) Compare(DateTime, DateTime) Compare(DateTime, DateTime)

DateTime의 두 인스턴스를 비교하고 첫 번째 인스턴스가 두 번째 인스턴스보다 빠른지, 같은지, 늦은지를 나타내는 정수를 반환합니다.Compares two instances of DateTime and returns an integer that indicates whether the first instance is earlier than, the same as, or later than the second instance.

CompareTo(DateTime) CompareTo(DateTime) CompareTo(DateTime) CompareTo(DateTime)

이 인스턴스의 값을 지정된 DateTime 값과 비교하고 이 인스턴스가 지정된 DateTime 값보다 이전인지, 같은지 또는 이후인지를 나타내는 정수를 반환합니다.Compares the value of this instance to a specified DateTime value and returns an integer that indicates whether this instance is earlier than, the same as, or later than the specified DateTime value.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

이 인스턴스의 값을 지정된 DateTime 값이 포함된 지정된 개체와 비교하고, 이 인스턴스가 지정된 DateTime 값보다 이전인지, 같은지 또는 이후인지를 나타내는 정수를 반환합니다.Compares the value of this instance to a specified object that contains a specified DateTime value, and returns an integer that indicates whether this instance is earlier than, the same as, or later than the specified DateTime value.

DaysInMonth(Int32, Int32) DaysInMonth(Int32, Int32) DaysInMonth(Int32, Int32) DaysInMonth(Int32, Int32)

지정된 월과 연도의 날짜 수를 반환합니다.Returns the number of days in the specified month and year.

Equals(DateTime, DateTime) Equals(DateTime, DateTime) Equals(DateTime, DateTime) Equals(DateTime, DateTime)

DateTime 인스턴스의 날짜 및 시간 값이 같은지를 나타내는 값을 반환합니다.Returns a value indicating whether two DateTime instances have the same date and time value.

Equals(DateTime) Equals(DateTime) Equals(DateTime) Equals(DateTime)

이 인스턴스의 값이 지정된 DateTime 인스턴스의 값과 같은지를 나타내는 값을 반환합니다.Returns a value indicating whether the value of this instance is equal to the value of the specified DateTime instance.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.Returns a value indicating whether this instance is equal to a specified object.

FromBinary(Int64) FromBinary(Int64) FromBinary(Int64) FromBinary(Int64)

64비트 이진 값을 deserialize하고 serialize된 원본 DateTime 개체를 다시 만듭니다.Deserializes a 64-bit binary value and recreates an original serialized DateTime object.

FromFileTime(Int64) FromFileTime(Int64) FromFileTime(Int64) FromFileTime(Int64)

지정한 Windows 파일 시간을 해당 현지 시간으로 변환합니다.Converts the specified Windows file time to an equivalent local time.

FromFileTimeUtc(Int64) FromFileTimeUtc(Int64) FromFileTimeUtc(Int64) FromFileTimeUtc(Int64)

지정한 Windows 파일 시간을 해당 UTC 시간으로 변환합니다.Converts the specified Windows file time to an equivalent UTC time.

FromOADate(Double) FromOADate(Double) FromOADate(Double) FromOADate(Double)

지정된 OLE 자동화 날짜에 해당하는 DateTime을 반환합니다.Returns a DateTime equivalent to the specified OLE Automation Date.

GetDateTimeFormats() GetDateTimeFormats() GetDateTimeFormats() GetDateTimeFormats()

이 인스턴스의 값을 표준 날짜 및 시간 서식 지정자에서 지원하는 모든 문자열 표현으로 변환합니다.Converts the value of this instance to all the string representations supported by the standard date and time format specifiers.

GetDateTimeFormats(Char) GetDateTimeFormats(Char) GetDateTimeFormats(Char) GetDateTimeFormats(Char)

이 인스턴스의 값을 지정된 표준 날짜 및 시간 서식 지정자에서 지원하는 모든 문자열 표현으로 변환합니다.Converts the value of this instance to all the string representations supported by the specified standard date and time format specifier.

GetDateTimeFormats(IFormatProvider) GetDateTimeFormats(IFormatProvider) GetDateTimeFormats(IFormatProvider) GetDateTimeFormats(IFormatProvider)

이 인스턴스의 값을 표준 날짜 및 시간 서식 지정자와 지정된 문화권별 서식 지정 정보에서 지원하는 모든 문자열 표현으로 변환합니다.Converts the value of this instance to all the string representations supported by the standard date and time format specifiers and the specified culture-specific formatting information.

GetDateTimeFormats(Char, IFormatProvider) GetDateTimeFormats(Char, IFormatProvider) GetDateTimeFormats(Char, IFormatProvider) GetDateTimeFormats(Char, IFormatProvider)

이 인스턴스의 값을 지정된 표준 날짜 및 시간 서식 지정자와 문화권별 서식 지정 정보에서 지원하는 모든 문자열 표현으로 변환합니다.Converts the value of this instance to all the string representations supported by the specified standard date and time format specifier and culture-specific formatting information.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

TypeCode 값 형식에 대한 DateTime를 반환합니다.Returns the TypeCode for value type DateTime.

IsDaylightSavingTime() IsDaylightSavingTime() IsDaylightSavingTime() IsDaylightSavingTime()

DateTime의 이 인스턴스가 현재 시간대의 일광 절약 시간 범위 내에 있는지를 나타냅니다.Indicates whether this instance of DateTime is within the daylight saving time range for the current time zone.

IsLeapYear(Int32) IsLeapYear(Int32) IsLeapYear(Int32) IsLeapYear(Int32)

지정된 연도가 윤년인지를 나타내는 표시를 반환합니다.Returns an indication whether the specified year is a leap year.

Parse(String) Parse(String) Parse(String) Parse(String)

현재 스레드 문화권의 규칙을 사용하여 날짜 및 시간의 문자열 표현을 해당 DateTime으로 변환합니다.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

문화권별 형식 정보를 사용하여 날짜 및 시간의 문자열 표현을 해당 DateTime으로 변환합니다.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

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

문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 문자열 표현을 포함하는 메모리 범위를 동등한 해당 DateTime으로 변환합니다.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles)

문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 문자열 표현을 해당 DateTime으로 변환합니다.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified format and culture-specific format information. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.The format of the string representation must match the specified format exactly.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified format, culture-specific format information, and style. 문자열 표현의 서식은 지정된 서식과 정확하게 일치해야 합니다. 그렇지 않으면 예외가 throw됩니다.The format of the string representation must match the specified format exactly or an exception is thrown.

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

지정된 형식 배열, 문화권별 형식 정보 및 스타일을 사용하여 지정된 날짜와 시간의 문자열 표현을 해당 DateTime 표현으로 변환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified array of formats, culture-specific format information, and style. 문자열 표현의 서식은 지정된 형식 중 최소한 하나와 정확하게 일치해야 합니다. 그렇지 않으면 예외가 throw됩니다.The format of the string representation must match at least one of the specified formats exactly or an exception is thrown.

SpecifyKind(DateTime, DateTimeKind) SpecifyKind(DateTime, DateTimeKind) SpecifyKind(DateTime, DateTimeKind) SpecifyKind(DateTime, DateTimeKind)

지정된 DateTime과 틱 수가 같지만 지정된 DateTime 값이 나타내듯이 현지 시간 또는 UTC(협정 세계시)로 지정되거나 둘 중 어느 것으로도 지정되지 않은 새 DateTimeKind 개체를 만듭니다.Creates a new DateTime object that has the same number of ticks as the specified DateTime, but is designated as either local time, Coordinated Universal Time (UTC), or neither, as indicated by the specified DateTimeKind value.

Subtract(DateTime) Subtract(DateTime) Subtract(DateTime) Subtract(DateTime)

이 인스턴스에서 지정된 날짜와 시간을 뺍니다.Subtracts the specified date and time from this instance.

Subtract(TimeSpan) Subtract(TimeSpan) Subtract(TimeSpan) Subtract(TimeSpan)

지정된 기간을 이 인스턴스에서 뺍니다.Subtracts the specified duration from this instance.

ToBinary() ToBinary() ToBinary() ToBinary()

현재 DateTime 개체를 나중에 DateTime 개체를 다시 만드는 데 사용할 수 있는 64비트 이진 값으로 serialize합니다.Serializes the current DateTime object to a 64-bit binary value that subsequently can be used to recreate the DateTime object.

ToFileTime() ToFileTime() ToFileTime() ToFileTime()

현재 DateTime 개체의 값을 Windows 파일 시간으로 변환합니다.Converts the value of the current DateTime object to a Windows file time.

ToFileTimeUtc() ToFileTimeUtc() ToFileTimeUtc() ToFileTimeUtc()

현재 DateTime 개체의 값을 Windows 파일 시간으로 변환합니다.Converts the value of the current DateTime object to a Windows file time.

ToLocalTime() ToLocalTime() ToLocalTime() ToLocalTime()

현재 DateTime 개체의 값을 현지 시간으로 변환합니다.Converts the value of the current DateTime object to local time.

ToLongDateString() ToLongDateString() ToLongDateString() ToLongDateString()

현재 DateTime 개체의 값을 해당하는 긴 날짜 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent long date string representation.

ToLongTimeString() ToLongTimeString() ToLongTimeString() ToLongTimeString()

현재 DateTime 개체의 값을 해당하는 긴 시간 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent long time string representation.

ToOADate() ToOADate() ToOADate() ToOADate()

이 인스턴스의 값을 해당 OLE 자동화 날짜로 변환합니다.Converts the value of this instance to the equivalent OLE Automation date.

ToShortDateString() ToShortDateString() ToShortDateString() ToShortDateString()

현재 DateTime 개체의 값을 해당하는 짧은 날짜 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent short date string representation.

ToShortTimeString() ToShortTimeString() ToShortTimeString() ToShortTimeString()

현재 DateTime 개체의 값을 해당하는 짧은 시간 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent short time string representation.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 현재 DateTime 개체의 값을 해당 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent string representation using the specified format and culture-specific format information.

ToString(String) ToString(String) ToString(String) ToString(String)

현재 문화권의 형식 규칙과 지정된 형식을 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent string representation using the specified format and the formatting conventions of the current culture.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent string representation using the specified culture-specific format information.

ToString() ToString() ToString() ToString()

현재 문화권의 형식 규칙을 사용하여 현재 DateTime 개체의 값을 해당하는 문자열 표현으로 변환합니다.Converts the value of the current DateTime object to its equivalent string representation using the formatting conventions of the current culture.

ToUniversalTime() ToUniversalTime() ToUniversalTime() ToUniversalTime()

현재 DateTime 개체의 값을 UTC(협정 세계시)로 변환합니다.Converts the value of the current DateTime object to Coordinated Universal Time (UTC).

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime) TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime) TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime) TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)
TryParse(String, DateTime) TryParse(String, DateTime) TryParse(String, DateTime) TryParse(String, DateTime)

날짜와 시간에 대한 지정된 문자열 표현을 해당 DateTime 요소로 변환하고, 변환에 성공했는지를 나타내는 값을 반환합니다.Converts the specified string representation of a date and time to its DateTime equivalent and returns a value that indicates whether the conversion succeeded.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

지정된 문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환하고 변환에 성공했는지를 나타내는 값을 반환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified culture-specific format information and formatting style, and returns a value that indicates whether the conversion succeeded.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 날짜 및 시간의 지정된 문자열 표현을 해당 DateTime으로 변환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified format, culture-specific format information, and style. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.The format of the string representation must match the specified format exactly. 이 메서드는 변환이 성공했는지 아니면 실패했는지를 나타내는 값을 반환합니다.The method returns a value that indicates whether the conversion succeeded.

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

지정된 형식 배열, 문화권별 형식 정보 및 스타일을 사용하여 지정된 날짜와 시간의 문자열 표현을 해당 DateTime 표현으로 변환합니다.Converts the specified string representation of a date and time to its DateTime equivalent using the specified array of formats, culture-specific format information, and style. 문자열 표현 형식은 지정된 형식과 정확히 일치해야 합니다.The format of the string representation must match at least one of the specified formats exactly. 이 메서드는 변환이 성공했는지 아니면 실패했는지를 나타내는 값을 반환합니다.The method returns a value that indicates whether the conversion succeeded.

연산자

Addition(DateTime, TimeSpan) Addition(DateTime, TimeSpan) Addition(DateTime, TimeSpan) Addition(DateTime, TimeSpan)

지정된 시간 간격을 지정된 날짜 및 시간에 더하여 새로운 날짜와 시간을 얻습니다.Adds a specified time interval to a specified date and time, yielding a new date and time.

Equality(DateTime, DateTime) Equality(DateTime, DateTime) Equality(DateTime, DateTime) Equality(DateTime, DateTime)

DateTime의 지정된 두 인스턴스가 같은지를 확인합니다.Determines whether two specified instances of DateTime are equal.

GreaterThan(DateTime, DateTime) GreaterThan(DateTime, DateTime) GreaterThan(DateTime, DateTime) GreaterThan(DateTime, DateTime)

지정된 DateTime이 지정된 다른 DateTime보다 나중인지를 판단합니다.Determines whether one specified DateTime is later than another specified DateTime.

GreaterThanOrEqual(DateTime, DateTime) GreaterThanOrEqual(DateTime, DateTime) GreaterThanOrEqual(DateTime, DateTime) GreaterThanOrEqual(DateTime, DateTime)

지정된 DateTime이 다른 지정된 DateTime과 같거나 나중인 날짜와 시간을 나타내는지를 결정합니다.Determines whether one specified DateTime represents a date and time that is the same as or later than another specified DateTime.

Inequality(DateTime, DateTime) Inequality(DateTime, DateTime) Inequality(DateTime, DateTime) Inequality(DateTime, DateTime)

DateTime의 지정된 두 인스턴스가 다른지를 확인합니다.Determines whether two specified instances of DateTime are not equal.

LessThan(DateTime, DateTime) LessThan(DateTime, DateTime) LessThan(DateTime, DateTime) LessThan(DateTime, DateTime)

지정된 DateTime이 지정된 다른 DateTime보다 이전인지를 판단합니다.Determines whether one specified DateTime is earlier than another specified DateTime.

LessThanOrEqual(DateTime, DateTime) LessThanOrEqual(DateTime, DateTime) LessThanOrEqual(DateTime, DateTime) LessThanOrEqual(DateTime, DateTime)

지정된 DateTime이 다른 지정된 DateTime과 같거나 이전인 날짜와 시간을 나타내는지를 결정합니다.Determines whether one specified DateTime represents a date and time that is the same as or earlier than another specified DateTime.

Subtraction(DateTime, TimeSpan) Subtraction(DateTime, TimeSpan) Subtraction(DateTime, TimeSpan) Subtraction(DateTime, TimeSpan)

지정된 날짜와 시간에서 지정된 시간 간격을 빼고 새 날짜와 시간을 반환합니다.Subtracts a specified time interval from a specified date and time and returns a new date and time.

Subtraction(DateTime, DateTime) Subtraction(DateTime, DateTime) Subtraction(DateTime, DateTime) Subtraction(DateTime, DateTime)

지정된 날짜와 시간을 지정된 다른 날짜와 시간에서 빼고 시간 간격을 반환합니다.Subtracts a specified date and time from another specified date and time and returns a time interval.

명시적 인터페이스 구현

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

현재 DateTime 개체를 반환합니다.Returns the current DateTime object.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

현재 DateTime 개체를 지정된 형식의 개체로 변환합니다.Converts the current DateTime object to an object of a specified type.

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

이 변환은 지원되지 않습니다.This conversion is not supported. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.Attempting to use this method throws an InvalidCastException.

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

현재 SerializationInfo 개체를 serialize하는 데 필요한 데이터로 DateTime 개체를 채웁니다.Populates a SerializationInfo object with the data needed to serialize the current DateTime object.

적용 대상

스레드 보안

이 유형의 모든 멤버는 스레드로부터 안전 합니다.All members of this type are thread safe. 인스턴스 상태를 수정 하려면 표시 되는 멤버는 실제로 새 값을 사용 하 여 초기화 된 새 인스턴스를 반환 합니다.Members that appear to modify instance state actually return a new instance initialized with the new value. 으로 다른 형식을 사용 하 여이 형식의 인스턴스를 포함 하는 공유 변수를 읽고 쓰는로 보호 되어야 스레드로부터 안전을 보장 하려면 잠금.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

추가 정보