DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

정의

날짜 및 시간에 대한 문자열 표현을 해당 DateTime으로 변환합니다.Converts the string representation of a date and time to its DateTime equivalent.

오버로드

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)

문화권별 형식 정보 및 서식 지정 스타일을 사용하여 날짜 및 시간의 문자열 표현을 포함하는 메모리 범위를 동등한 해당 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.

예제

호출 하는 다양 한 예제는 DateTime.Parse 메서드는 재생 중에 삽입 합니다 주의 개인에 대 한 설명서 및이 문서의 섹션 DateTime.Parse 오버 로드 합니다.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

참고

이 문서의 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.Parse 에 포함 된 예는 C#에 대 한.NET Core 2.0 프로젝트Visual Basic.NET Core 2.0 프로젝트에서 dotnet / 샘플 GitHub 리포지토리합니다.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

설명

섹션 내용In this section:

메서드 호출 합니까?Which method do I call?

대상To CallCall
현재 문화권의 규칙을 사용 하 여 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string by using the conventions of the current culture. Parse(String) 오버로드Parse(String) overload
특정 문화권의 규칙을 사용 하 여 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider) 오버 로드 (참조 구문 분석 및 문화권별 표기법)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
특별 한 스타일 요소 (예: 공백 문자 또는 공백이 없음)를 사용 하 여 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string with special style elements (such as white space or no white space). Parse(String, IFormatProvider, DateTimeStyles) 오버로드Parse(String, IFormatProvider, DateTimeStyles) overload
특정 형식 이어야 하는 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string that must be in a particular format. DateTime.ParseExact 또는 DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
날짜 및 시간 문자열 구문 분석 하 고 UTC 또는 현지 시간으로의 변환을 수행 합니다.Parse a date and time string and perform a conversion to UTC or local time. Parse(String, IFormatProvider, DateTimeStyles) 오버로드Parse(String, IFormatProvider, DateTimeStyles) overload
예외를 처리 하지 않고 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string without handling exceptions. DateTime.TryParse 메서드DateTime.TryParse method
서식 지정 작업에서 만든 날짜 및 시간 값 (라운드트립)을 복원 합니다.Restore (round-trip) a date and time value created by a formatting operation. "O" 또는 "r" 표준 서식 문자열을 전달 하는 ToString(String) 메서드를 호출 합니다 Parse(String, IFormatProvider, DateTimeStyles) 오버 로드 DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
컴퓨터 (및 가능한 경우 문화권) 경계를 넘어 고정 형식으로 날짜 및 시간 문자열 구문 분석 합니다.Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExact 또는 DateTime.TryParseExact 메서드DateTime.ParseExact or DateTime.TryParseExact method

구문 분석할 문자열The string to parse

합니다 Parse 메서드는 날짜 및 시간 값의 문자열 표현으로 변환 하려고 합니다. 해당 DateTime 동일 합니다.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. throw 하지 않고 완전히 입력된 문자열을 구문 분석을 FormatException 예외입니다.It tries to parse the input string completely without throwing a FormatException exception.

중요

구문 분석 작업을 인식할 수 없는 문자열 형식으로 인해 실패 하면를 Parse 메서드가 throw를 FormatException반면 합니다 TryParse 메서드가 반환 되는 false합니다.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. 예외 처리 비용이 많이 들 수, 있으므로 사용 해야 Parse 구문 분석 작업이 입력된 소스는 신뢰할 수 있는 때문에 성공 하려면 예상 되는 경우.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse 구문 분석 오류 가능성이 되 면 입력된 원본을 신뢰할 수 없거나 성공적으로 구문 분석 하지 않습니다 하는 문자열에 대 한 대체 값이 적절 한 기본값 때문에 특히 것이 좋습니다.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

구문 분석 될 문자열이 다음 형식 중 하나를 사용할 수 있습니다.The string to be parsed can take any of the following forms:

  • 날짜 및 시간 구성 요소에 있는 string입니다.A string with a date and a time component.

  • 날짜 시간 구성 요소가 없는 같지만 문자열입니다.A string with a date but no time component. 시간 구성 요소가 없으면 메서드는 자정 12 시를 가정 합니다.If the time component is absent, the method assumes 12:00 midnight. 날짜 구성 요소에는 두 자리 연도를 기준으로 변환 됩니다 합니다 Calendar.TwoDigitYearMax 현재 문화권의 현재 달력의 지정된 된 문화권의 현재 달력 (null이 아닌을 사용 하 여 오버 로드를 사용 하는 경우 provider 인수).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • 월 및 연도 포함 하는 날짜 구성 요소가 있지만 없습니다 일 구성 요소는 문자열입니다.A string with a date component that includes only the month and the year but no day component. 메서드는 해당 월의 첫 번째 날을 가정합니다.The method assumes the first day of the month.

  • 월과 일을 포함 하는 날짜 구성 요소가 있지만 없습니다 연도 구성 요소는 문자열입니다.A string with a date component that includes only the month and the day but no year component. 메서드는 현재 연도 가정합니다.The method assumes the current year.

  • 시간만 없는 날짜 구성 요소가 있는 string입니다.A string with a time but no date component. 메서드를 호출 하지 않으면 현재 날짜를 가정 합니다 Parse(String, IFormatProvider, DateTimeStyles) 오버 로드 하 고 포함 DateTimeStyles.NoCurrentDateDefaultstyles 인수에 있는 경우 메서드가 가정 년 1 월 1 일 날짜를 0001 합니다.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • 시간만 및 날짜 구성 요소가 없는 AM/PM 지정자를 포함 하는 시간 구성 요소는 문자열입니다.A string with a time component that includes only the hour and an AM/PM designator, with no date component. 메서드는 현재 날짜와 없는 분 및 초가 없는 시간을 가정합니다.The method assumes the current date and a time with no minutes and no seconds. 호출 하 여이 동작을 변경할 수는 Parse(String, IFormatProvider, DateTimeStyles) 오버 로드 하 고 포함 DateTimeStyles.NoCurrentDateDefaultstyles 인수에 있는 경우 메서드가 가정 년 1 월 1 일 날짜를 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • 표준 시간대 정보를 포함 하 고 ISO 8601을 준수 하는 문자열입니다.A string that includes time zone information and conforms to ISO 8601. 다음 예제에서는 첫 번째 문자열 utc (협정 세계시)를 지정 하 고는 7 시간 표준 시간대의 시간을 지정 하는 두 번째 UTC 보다 이전 버전:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

    "2008-11-01T19:35:00.0000000Z""2008-11-01T19:35:00.0000000Z"
    "2008-11-01T19:35:00.0000000-07:00""2008-11-01T19:35:00.0000000-07:00"

  • RFC 1123 시간 형식을; 및 GMT 지정자를 포함 하는 문자열 예를 들어:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "2008 년 11 월 01, 토요일 19시 35분: 00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • 날짜 및 시간과 표준 시간대 오프셋된 정보를 포함 하는 문자열 예를 들어:A string that includes the date and time along with time zone offset information; for example:

    "2009-03-01 05시 42분: 00-5:00""03/01/2009 05:42:00 -5:00"

다음 예제에서는 EN-US 문화권에이 경우에 현재 문화권의 서식 규칙을 사용 하 여 각 형식의 문자열을 구문 분석:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),                             
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };
   
      Console.WriteLine($"Today is {DateTime.Now:d}\n");
      
      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");        
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//   
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM


Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

입력된 문자열 구문 분석 메서드에서 사용 되는 달력 윤년에서 윤 일을 나타내는 경우 (참조 규칙을 구문 분석 및 문화적), Parse 메서드 문자열을 성공적으로 구문 분석 합니다.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. 입력된 문자열에서 비-윤년 윤 일을 나타내는 경우 메서드에서 throw 한 FormatException합니다.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

때문에 Parse 메서드는 날짜의 문자열 표현을 구문 분석 하려고 시도 하 고 현재 또는 서로 다른 문화권에서 문자열을 구문 분석 하는 동안 지정된 된 문화권의 서식 규칙을 사용 하 여 실패할 수 있습니다.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. 여러 로캘에서 특정 날짜 및 시간 서식을 구문 분석, 오버 로드 중 하나를 사용 합니다 DateTime.ParseExact 메서드 형식 지정자를 제공 합니다.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

구문 분석 및 문화적 규칙Parsing and cultural conventions

모든 오버 로드는 Parse 메서드는 문화권을 구분 하지 않는 한 구문 분석 될 문자열 (으로 나타나는 s 표에) ISO 8601 패턴을 따르는.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. 구문 분석 작업에서 서식 지정 정보를 사용 하는 DateTimeFormatInfo 다음과 같이 파생 되는 개체:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

중요

일본어 달력의 시대는 천황 통치 기간을 기준으로 하므로 변경되어야 합니다.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. 예를 들어 2019년 5월 1일은 JapaneseCalendarJapaneseLunisolarCalendar에서 레이와 시대의 시작을 나타냅니다.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. 이러한 시대 변경 내용은 해당 달력을 사용하는 모든 애플리케이션에 영향을 줍니다.Such a change of era 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. 여러 시대가 포함된 달력을 지원하는 .NET의 기능과 여러 시대를 지원하는 달력을 사용할 때 모범 사례에 대해서는 시대 작업을 참조하세요.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

호출 하는 경우If you call provider 됩니다And provider is 서식 지정 정보에서 파생 됩니다.Formatting information is derived from
Parse(String) - 현재 스레드 문화권 (DateTimeFormatInfo.CurrentInfo 속성)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) 또는 Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) DateTimeFormatInfo 개체a DateTimeFormatInfo object 지정 된 DateTimeFormatInfo 개체The specified DateTimeFormatInfo object
Parse(String, IFormatProvider) 또는 Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null 현재 스레드 문화권 (DateTimeFormatInfo.CurrentInfo 속성)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) 또는 Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) CultureInfo 개체a CultureInfo object CultureInfo.DateTimeFormat 속성The CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) 또는 Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) 사용자 지정 IFormatProvider 구현Custom IFormatProvider implementation IFormatProvider.GetFormat 메서드The IFormatProvider.GetFormat method

면에서 파생 된 형식 지정 정보를 DateTimeFormatInfo 개체는 DateTimeFormatInfo.Calendar 속성은 구문 분석 작업에 사용 되는 일정을 정의 합니다.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

사용 하 여 날짜 및 시간 문자열을 구문 분석 하는 경우는 DateTimeFormatInfo 사용자 지정 표준 문화권을 다른 설정을 사용 하 여 개체를 사용 합니다 ParseExact 메서드 대신는 Parse 성공적인 변환에 대 한 가능성을 개선 하는 방법.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. 비표준 날짜 및 시간 문자열에는 복잡 하 고 구문 분석 하기 어려울 수 있습니다.A non-standard date and time string can be complicated and difficult to parse. Parse 메서드는 실패할 수 있습니다는 모두 여러 암시적 구문 분석 패턴을 사용 하 여 문자열 구문 분석 하려고 합니다.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. 반면,는 ParseExact 메서드를 사용 하면 성공 가능성이 있는 정확한 구문 분석 패턴을 하나 이상의 명시적으로 지정 해야 합니다.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. 자세한 내용은 "DateTimeFormatInfo 및 동적 데이터" 섹션을 참조 하세요.를 DateTimeFormatInfo 항목입니다.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

중요

에 불과하며 특정 문화권의 서식 규칙은 동적 변경 될 수 있습니다.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. 이 즉, 또는 기본값 (현재) 문화권의 서식 규칙에 종속 된 구문 분석 작업을 지정 하는 IFormatProvider 고정 문화권이 아닌 문화권을 나타내는 개체는 다음 중 하나라도 발생 하는 경우에 예기치 않게 실패할 수 있습니다.This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Culture 별 데이터의.NET Framework 또는.NET Framework의 기존 버전에 대 한 업데이트의 결과로 또는 부 버전 간에 변경 되었습니다.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Culture 별 데이터를 컴퓨터에서 컴퓨터 또는 세션 달라질 수 있는 사용자 기본 설정을 반영 합니다.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Culture 별 데이터는 표준 문화권 또는 사용자 지정 문화권의 설정을 재정의 하는 대체 문화권을 나타냅니다.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

문화권 데이터의 변경 내용과 연결 된 데이터 및 시간 문자열 구문 분석 문제를 방지 하려면 고정 문화권을 사용 하 여 날짜 및 시간 문자열을 구문 분석할 수 있습니다 하거나 호출할 수 있습니다 합니다 ParseExact 또는 TryParseExact 메서드 정확한 형식을 지정 합니다. 구문 분석 될 문자열입니다.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. 직렬화 되 고 날짜 및 시간 데이터를 역직렬화 하는 동안, 사용 하거나 고정 문화권의 서식 규칙 또는 serialize 및 deserialize 할 수 있습니다 하는 경우는 DateTime 이진 형식에서 값입니다.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

자세한 내용은 "동적 culture 데이터" 섹션을 참조 하세요. 합니다 CultureInfo 항목과 "유지 DateTime 값" 섹션을 DateTime 항목입니다.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

구문 분석 하 고 style 요소Parsing and style elements

모든 Parse 오버 로드는 입력된 문자열에서 선행, 내부 또는 후행 공백 문자 무시 (으로 나타나는 s 표에).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). 날짜 및 시간을 선행 및 후행 숫자 기호 문자 ("#", U + 00-23), 쌍을 사용 하 여 대괄호로 묶어야 하 고 하나를 사용 하 여 올 수 있습니다 또는 이상의 NULL 문자 (U + 0000)입니다.The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

또한 합니다 Parse(String, IFormatProvider, DateTimeStyles) 오버 로드에는 styles 의 하나 이상의 멤버로 구성 된 매개 변수는 DateTimeStyles 열거형입니다.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. 이 매개 변수를 정의 하는 방법을 s 해석 되어야 하 고 구문 분석 작업으로 변환 해야 하는 방법을 s 날짜 및 시간입니다.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. 다음 표에서 각 미치는 DateTimeStyles 구문 분석 작업에는 멤버입니다.The following table describes the effect of each DateTimeStyles member on the parse operation.

DateTimeStyles 멤버DateTimeStyles member 변환에 미치는 영향Effect on conversion
AdjustToUniversal 구문 분석 s 필요한 UTC로 변환, 다음과 같은 경우:Parses s and, if necessary, converts it to UTC, as follows:

- s 표준 시간대 오프셋을 포함 이거나 s 시간대 정보가 없습니다 있지만 styles 포함 합니다 AssumeLocal 플래그를 메서드 호출 문자열 구문 분석 ToUniversalTime 반환 된 변환할 DateTime 값을 UTC 및 집합은 Kind 속성을 DateTimeKind.Utc입니다.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
- s UTC를 나타냅니다 이거나 s 표준 시간대 정보를 포함 하지 있지만 styles 포함 합니다 AssumeUniversal 플래그를 메서드 문자열을 구문 분석, 반환 된 표준 시간대 변환 작업 없이 수행 DateTime 값 집합과 합니다 Kind 속성을 DateTimeKind.Utc입니다.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-다른 모든 경우 플래그에 영향을 주지 않습니다.- In all other cases, the flag has no effect.
AllowInnerWhite 이 값은 무시됩니다.This value is ignored. 날짜 및 시간 요소에 내부 공백을 허용 항상 s합니다.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite 이 값은 무시됩니다.This value is ignored. 날짜 및 시간 요소에서 선행 공백을 허용 항상 s합니다.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite 이 값은 무시됩니다.This value is ignored. 날짜 및 시간 요소에 항상 허용 됩니다 후행 공백을 s합니다.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces 지정 s 선행, 내부 및 후행 공백을 포함할 수 있습니다.Specifies that s may contain leading, inner, and trailing white spaces. 이것은 기본적인 동작입니다.This is the default behavior. 더 제한적인 제공 하 여 재정의할 수 없습니다 DateTimeStyles 와 같은 열거형 값 None합니다.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal 지정 합니다 s 에 현지 시간을 표준 시간대 정보를 사용 하는 것으로 간주 합니다.Specifies that if s lacks any time zone information, local time is assumed. 경우가 아니면 합니다 AdjustToUniversal 플래그가 없으면 합니다 Kind 반환 된 속성 DateTime 값으로 설정 됩니다 DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal 지정 합니다 s 없는 UTC 표준 시간대 정보가 있는 것으로 간주 됩니다.Specifies that if s lacks any time zone information, UTC is assumed. 경우가 아니면 합니다 AdjustToUniversal 플래그가, 메서드가 반환 된 변환 하는 DateTime 값을 UTC에서 현지 시간 및 집합 해당 Kind 속성을 DateTimeKind.Local입니다.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None 유효 하더라도이 값은 무시 됩니다.Although valid, this value is ignored.
RoundtripKind 표준 시간대 정보가 포함 된 문자열의 경우 날짜 및 시간 문자열을 변환 하지 않으려면 시도 DateTime 와 현지 시간을 나타내는 해당 Kind 속성이로 설정 DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. 호출 하 여 이러한 문자열은 생성 하는 일반적으로 DateTime.ToString(String) 메서드 "o", "r" 또는 "u" 표준 서식 지정자를 사용 하 여 합니다.Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

반환 값과 DateTime.KindThe return value and DateTime.Kind

합니다 DateTime.Parse 반환 오버 로드를 DateTimeKind 속성에는 표준 시간대 정보가 포함 됩니다.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. 이 시간을 나타낼 수 있습니다.It can indicate that the time is:

일반적으로 Parse 메서드가 반환 되는 DateTime 개체입니다 Kind 속성은 DateTimeKind.Unspecified합니다.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. 그러나 합니다 Parse 도 표준 시간대 변환을 수행 하 고의 값을 설정할 수 있습니다 메서드는 Kind 속성 값에 따라 다르게 합니다 sstyles 매개 변수:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

조건If 표준 시간대 변환Time zone conversion Kind 속성Kind property
s 표준 시간대 정보를 포함합니다.s contains time zone information. 날짜 및 시간을 현지 표준 시간대의 시간으로 변환 됩니다.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s 표준 시간대 정보를 포함 하 고 styles 포함을 AdjustToUniversal 플래그 합니다.s contains time zone information, and styles includes the AdjustToUniversal flag. 날짜 및 시간을 utc (협정 세계시)로 변환 됩니다.The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s Z 또는 GMT 표준 시간대 지정자를 포함 하 고 styles 포함을 RoundtripKind 플래그입니다.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. 날짜 및 시간을 UTC로 해석 됩니다.The date and time are interpreted as UTC. DateTimeKind.Utc

다음 예제에서는 현지 표준 시간대의 시간 표준 시간대 정보를 포함 하는 날짜 문자열을 변환 합니다.The following example converts date strings that contain time zone information to the time in the local time zone:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00", 
                              "2008-05-01 7:34:42Z", 
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }                              
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM                                             
Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM                                             

날짜 및 시간 값을 유지할 수 있습니다 Kind 서식 및 사용 하 여 작업을 구문 분석 중에 속성을 DateTimeStyles.RoundtripKind 플래그입니다.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. 다음 예제는 방법을 RoundtripKind 플래그에 구문 분석 작업에 영향을 줍니다 DateTime "o", "r" 또는 "u" 서식 지정자를 사용 하 여 문자열로 변환 되는 값입니다.The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00", 
                               "2008-09-15T09:30:41.7752486Z",  
                               "2008-09-15T09:30:41.7752486",  
                               "2008-09-15T09:30:41.7752486-04:00", 
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null, 
                                              DateTimeStyles.RoundtripKind);                        
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");
   
      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null, 
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }         
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.      
Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.      

#

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.

public:
 static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime

매개 변수

s
String String String String

변환할 날짜 및 시간이 포함된 문자열입니다.A string that contains a date and time to convert. 자세한 내용은 구문 분석할 문자열을 참조하세요.See The string to parse for more information.

반환

s에 포함된 날짜 및 시간에 해당하는 개체입니다.An object that is equivalent to the date and time contained in s.

예외

s에 날짜 및 시간의 유효한 문자열 표현이 없습니다.s does not contain a valid string representation of a date and time.

설명

경우 s 이 메서드는 반환 표준 시간대 정보를 포함를 DateTimeKind 속성이 DateTimeKind.Local 날짜 및 시간을 변환 하 고 s 를 현지 시간입니다.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. 그렇지 않은 경우 표준 시간대 변환 작업 없이 수행 하 고 반환을 DateTimeKind 속성은 DateTimeKind.Unspecified합니다.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

이 오버 로드를 구문 분석 하려고 s 현재 문화권의 서식 규칙을 사용 하 여 합니다.This overload attempts to parse s by using the formatting conventions of the current culture. 현재 문화권으로 표시 됩니다는 CurrentCulture 속성입니다.The current culture is indicated by the CurrentCulture property. 특정 문화권의 서식 규칙을 사용 하 여 문자열 구문 분석을 호출 합니다 Parse(String, IFormatProvider) 또는 Parse(String, IFormatProvider, DateTimeStyles) 오버 로드 합니다.To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

이 오버 로드를 구문 분석 하려고 s 를 사용 하 여 DateTimeStyles.AllowWhiteSpaces 스타일입니다.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

예제Example

다음 예제에서는 여러 날짜 및 시간 값의 문자열 표현을 구문 분석:The following example parses the string representation of several date and time values by:

  • 예제 출력을 생성 하는 데 사용 하는 컴퓨터의 현재 스레드 문화권의 서식 규칙을 제공 하는 기본 형식 공급자를 사용 합니다.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. 이 예제의 출력은 EN-US 문화권의 서식 규칙을 반영합니다.The output from this example reflects the formatting conventions of the en-US culture.

  • 인 기본 스타일 값을 사용 하 여 AllowWhiteSpaces입니다.Using the default style value, which is AllowWhiteSpaces.

처리는 FormatException 메서드를 다른 문화권을 사용 하 여 날짜 및 시간의 문자열 표현을 구문 분석 하려고 할 때 throw 되는 예외 규칙의 서식 지정 합니다.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. 또한 현재 스레드 문화권의 서식 규칙을 사용 하지 않는 날짜 및 시간 값을 구문 분석 하는 방법을 보여 줍니다.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US. 
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
            
      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.      
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
      
      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }   
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
추가 정보

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.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public static DateTime Parse (string s, IFormatProvider provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

매개 변수

s
String String String String

변환할 날짜 및 시간이 포함된 문자열입니다.A string that contains a date and time to convert. 자세한 내용은 구문 분석할 문자열을 참조하세요.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

s에 대한 문화권별 서식 지정 정보를 제공하는 개체입니다.An object that supplies culture-specific format information about s. 구문 분석 및 문화적 규칙을 참조하세요.See Parsing and cultural conventions

반환

s에 지정된 내용에 따라 provider에 포함된 날짜 및 시간에 해당하는 개체입니다.An object that is equivalent to the date and time contained in s as specified by provider.

예외

s에 날짜 및 시간의 유효한 문자열 표현이 없습니다.s does not contain a valid string representation of a date and time.

설명

경우 s 이 메서드는 반환 표준 시간대 정보를 포함를 DateTimeKind 속성이 DateTimeKind.Local 날짜 및 시간을 변환 하 고 s 를 현지 시간입니다.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. 그렇지 않은 경우 표준 시간대 변환 작업 없이 수행 하 고 반환을 DateTimeKind 속성은 DateTimeKind.Unspecified합니다.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

이 오버 로드를 구문 분석 하려고 s 를 사용 하 여는 DateTimeStyles.AllowWhiteSpaces 스타일입니다.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

예제Example

다음 예에서는 고 EN-US, FR-FR, DE-DE 문화권의 규칙을 사용 하 여 날짜 문자열의 배열 구문 분석 합니다.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. 다른 문화권에 걸쳐 단일 날짜의 문자열 표현을 다르게 해석 될 수 있는지를 보여 줍니다.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"), 
                                CultureInfo.CreateSpecificCulture("fr-FR"), 
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM", 
                              "10.01.2009 19:34", 
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.", 
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", 
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }                                                                                     
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//       
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//       
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
추가 정보

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.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = null, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

매개 변수

s
ReadOnlySpan<Char>

구문 분석할 문자열을 포함하는 메모리 범위입니다.The memory span that contains the string to parse. 자세한 내용은 구문 분석할 문자열을 참조하세요.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

s에 대한 문화권별 서식 지정 정보를 제공하는 개체입니다.An object that supplies culture-specific format information about s. 구문 분석 및 문화적 규칙을 참조하세요.See Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

구문 분석 작업이 성공하기 위해 s에 있을 수 있는 스타일 요소를 나타내는 열거형 값의 비트 조합으로, 현재 시간대 또는 현재 날짜와 비교하여 구문 분석된 날짜를 해석할 방법을 정의합니다.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. 지정할 일반적인 값은 None입니다.A typical value to specify is None.

반환

sprovider에 지정된 내용에 따라 styles에 포함된 날짜 및 시간에 해당하는 개체입니다.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

예외

s에 날짜 및 시간의 유효한 문자열 표현이 없습니다.s does not contain a valid string representation of a date and time.

stylesDateTimeStyles 값의 잘못된 조합이 포함되어 있습니다.styles contains an invalid combination of DateTimeStyles values. 예를 들어 AssumeLocalAssumeUniversal이 포함되어 있습니다.For example, both AssumeLocal and AssumeUniversal.

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.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

매개 변수

s
String String String String

변환할 날짜 및 시간이 포함된 문자열입니다.A string that contains a date and time to convert. 자세한 내용은 구문 분석할 문자열을 참조하세요.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

s에 대한 문화권별 형식 지정 정보를 제공하는 개체입니다.An object that supplies culture-specific formatting information about s. 구문 분석 및 문화적 규칙을 참조하세요.See Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles DateTimeStyles

구문 분석 작업이 성공하기 위해 s에 있을 수 있는 스타일 요소를 나타내는 열거형 값의 비트 조합으로, 현재 시간대 또는 현재 날짜와 비교하여 구문 분석된 날짜를 해석할 방법을 정의합니다.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. 지정할 일반적인 값은 None입니다.A typical value to specify is None.

반환

sprovider에 지정된 내용에 따라 styles에 포함된 날짜 및 시간에 해당하는 개체입니다.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

예외

s에 날짜 및 시간의 유효한 문자열 표현이 없습니다.s does not contain a valid string representation of a date and time.

stylesDateTimeStyles 값의 잘못된 조합이 포함되어 있습니다.styles contains an invalid combination of DateTimeStyles values. 예를 들어 AssumeLocalAssumeUniversal이 포함되어 있습니다.For example, both AssumeLocal and AssumeUniversal.

설명

이 메서드 오버 로드 된 날짜와 시간으로 변환 s 가져오거나 설정 합니다 Kind 반환 된 속성 DateTime 다음과 같이 값:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

조건If 표준 시간대 변환Time zone conversion Kind 속성Kind property
s 표준 시간대 정보가 없습니다.s contains no time zone information. 없음None. DateTimeKind.Unspecified
s 표준 시간대 정보를 포함합니다.s contains time zone information. 현지 표준 시간대의 시간To the time in the local time zone DateTimeKind.Local
s 표준 시간대 정보를 포함 하 고 ' 스타일 포함는 DateTimeStyles.AdjustToUniversal 플래그입니다. UTC (Coordinated Universal Time)에 DateTimeKind.Utcs contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag.
s Z 또는 GMT 표준 시간대 지정자를 포함 하 고 styles 포함을 DateTimeStyles.RoundtripKind입니다.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. 없음None. Utc

예제Example

다음 예제는 Parse(String, IFormatProvider, DateTimeStyles) 메서드 값을 표시 하 고는 Kind 결과 속성 DateTime 값입니다.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;
      
      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", 
                           dateString);
      }      
      
      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
      
      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is 
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
      
      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }                     
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      

      // Assume a date and time string formatted for the fr-FR culture is the local 
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.", 
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }      
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
추가 정보

적용 대상