DateTime.Parse 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将日期和时间的字符串表示形式转换为其等效 DateTime。

重载

Parse(String)	使用当前区域性的约定将日期和时间的字符串表示形式转换为其等效 DateTime。
Parse(ReadOnlySpan<Char>, IFormatProvider)	将字符的范围分析为值。
Parse(String, IFormatProvider)	使用区域性特定的格式信息将日期和时间的字符串表示形式转换为其等效 DateTime。
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	使用区域性特定的格式信息和格式样式，将包含日期和时间字符串表示形式的内存范围转换为其等效 DateTime。
Parse(String, IFormatProvider, DateTimeStyles)	使用区域性特定的格式信息和格式样式将日期和时间的字符串表示形式转换为其等效 DateTime。

示例

在本文的备注部分以及各个 DateTime.Parse 重载的文档中，许多调用 DateTime.Parse 方法的示例都插在一起。

注意

本文中的一些 C# 示例在 Try.NET 内联代码运行程序和操场中运行。选择运行以在交互窗口中运行示例。执行代码后，可以通过再次选择运行来修改代码并运行修改的代码。修改的代码要么在交互式窗口中运行，要么如果编译失败，交互式窗口将显示所有 C# 编译器错误消息。

Try.NET 内联代码运行程序和操场的本地时区是协调世界时或 UTC。这可能会影响说明 DateTime、DateTimeOffset和 TimeZoneInfo 类型和成员的示例的行为和输出。

还可以下载一组完整的示例，这些示例包含在适用于 C#的 .NET Core 项目中。

注解

在本部分中：

我调用哪种方法？
要分析的字符串
分析和文化约定
分析和样式元素
返回值和 DateTime.Kind

我调用哪种方法？

自	叫
使用当前区域性的约定分析日期和时间字符串。	Parse(String) 重载
使用特定区域性的约定分析日期和时间字符串。	Parse(String, IFormatProvider) 重载（请参阅分析和文化公约）
分析具有特殊样式元素的日期和时间字符串（如空格或无空格）。	Parse(String, IFormatProvider, DateTimeStyles) 重载
分析必须采用特定格式的日期和时间字符串。	DateTime.ParseExact 或 DateTime.TryParseExact
分析日期和时间字符串，并执行到 UTC 或本地时间的转换。	Parse(String, IFormatProvider, DateTimeStyles) 重载
分析日期和时间字符串而不处理异常。	DateTime.TryParse 方法
还原（往返）格式设置操作创建的日期和时间值。	将“o”或“r”标准格式字符串传递给 ToString(String) 方法，并使用 DateTimeStyles.RoundtripKind 调用 Parse(String, IFormatProvider, DateTimeStyles) 重载
跨计算机（甚至区域性）边界以固定格式分析日期和时间字符串。	DateTime.ParseExact 或 DateTime.TryParseExact 方法

要分析的字符串

Parse 方法尝试将日期和时间值的字符串表示形式转换为其等效 DateTime。它尝试完全分析输入字符串，而不会引发 FormatException 异常。

重要

如果分析操作由于无法识别的字符串格式而失败，Parse 方法将引发 FormatException，而 TryParse 方法返回 false。由于异常处理可能很昂贵，因此当分析操作预期成功时，应使用 Parse，因为输入源受信任。分析失败时，最好 TryParse，特别是因为输入源不受信任，或者你有合理的默认值来替代未成功分析的字符串。

要分析的字符串可以采用以下任何形式：

包含日期和时间组件的字符串。
包含日期但没有时间组件的字符串。如果时间组件不存在，则该方法假定午夜为 12：00。如果日期组件有两位数的年份，则会根据当前区域性的当前日历或指定区域性的当前日历的 Calendar.TwoDigitYearMax（如果使用具有非 null provider 参数的重载），将其转换为一年。
包含仅包含月份和年份但不包含日期组件的字符串。该方法假定月份的第一天。
包含仅包含月份和日期但不包含年份组件的日期组件的字符串。该方法假定当前年份。
具有时间但无日期组件的字符串。该方法假定当前日期，除非调用 Parse(String, IFormatProvider, DateTimeStyles) 重载并在 styles 参数中包含 DateTimeStyles.NoCurrentDateDefault，在这种情况下，该方法假定日期为 0001 年 1 月 1 日。
包含仅包含小时和 AM/PM 设计符的时间组件的字符串，不包含日期组件。该方法假定当前日期和时间，不带分钟和秒。可以通过调用 Parse(String, IFormatProvider, DateTimeStyles) 重载来更改此行为，并在 styles 参数中包含 DateTimeStyles.NoCurrentDateDefault，在这种情况下，该方法假定日期为 0001 年 1 月 1 日。
包含时区信息的字符串，符合 ISO 8601。在以下示例中，第一个字符串指定协调世界时（UTC），第二个字符串指定比 UTC 早七个小时的时区中的时间：

“2008-11-01T19：35：00.0000000Z” “2008-11-01T19：35：00.0000000-07：00”
包含 GMT 设计符并符合 RFC 1123 时间格式的字符串;例如：

“2008年11月1日星期六 19：35：00 GMT”
包含日期和时间以及时区偏移信息的字符串;例如：

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

以下示例使用当前区域性的格式设置约定（在本例中为 en-US 区域性）分析每种格式的字符串：

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

module Parse6

open System

let  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" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(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

如果输入字符串表示分析方法使用的日历中的 leap 日（请参阅分析和文化约定），则 Parse 方法成功分析字符串。如果输入字符串表示非 leap 年份中的一个跃点，该方法将引发 FormatException。

由于 Parse 方法尝试使用当前或指定区域性的格式规则分析日期和时间的字符串表示形式，因此尝试跨不同区域性分析字符串可能会失败。若要分析不同区域设置的特定日期和时间格式，请使用 DateTime.ParseExact 方法的重载之一并提供格式说明符。

分析和文化约定

除非要分析的字符串（下表中的 s 表示）符合 ISO 8601 模式，否则 Parse 方法的所有重载都区分区域性。分析操作在派生的 DateTimeFormatInfo 对象中使用格式信息，如下所示：

重要

日本日历中的纪元基于皇帝的统治，因此预计将改变。例如，2019 年 5 月 1 日标志着雷瓦时代在 JapaneseCalendar 和 JapaneseLunisolarCalendar的开始。这种时代变化会影响使用这些日历的所有应用程序。有关详细信息并确定应用程序是否受到影响，请参阅处理 .NET日本日历中的新纪元。有关在 Windows 系统上测试应用程序以确保其为纪元更改做好准备的信息，请参阅为日本时代更改准备应用程序。有关支持具有多个纪元的日历以及处理支持多个纪元的日历的最佳做法的 .NET 中的功能，请参阅使用纪元。

如果调用	`provider`	格式设置信息派生自
Parse(String)	-	当前区域性（DateTimeFormatInfo.CurrentInfo 属性）
Parse(String, IFormatProvider) 或 Parse(String, IFormatProvider, DateTimeStyles)	DateTimeFormatInfo 对象	指定的 DateTimeFormatInfo 对象
Parse(String, IFormatProvider) 或 Parse(String, IFormatProvider, DateTimeStyles)	`null`	当前区域性（DateTimeFormatInfo.CurrentInfo 属性）
Parse(String, IFormatProvider) 或 Parse(String, IFormatProvider, DateTimeStyles)	CultureInfo 对象	CultureInfo.DateTimeFormat 属性
Parse(String, IFormatProvider) 或 Parse(String, IFormatProvider, DateTimeStyles)	自定义 IFormatProvider 实现	IFormatProvider.GetFormat 方法

当格式化信息派生自 DateTimeFormatInfo 对象时，DateTimeFormatInfo.Calendar 属性定义分析操作中使用的日历。

如果使用与标准区域性不同的自定义设置的 DateTimeFormatInfo 对象来分析日期和时间字符串，请使用 ParseExact 方法而不是 Parse 方法来提高成功转换的机会。非标准日期和时间字符串可能很复杂，难以分析。 Parse 方法尝试分析具有多个隐式分析模式的字符串，所有这些模式都可能失败。相比之下，ParseExact 方法要求显式指定一个或多个可能成功的确切分析模式。有关详细信息，请参阅 DateTimeFormatInfo 主题中的“DateTimeFormatInfo 和动态数据”部分。

重要

请注意，特定区域性的格式设置约定是动态的，可能会更改。这意味着，分析依赖于默认（当前）区域性的格式设置约定或指定表示固定区域性以外的区域性的 IFormatProvider 对象，如果发生以下任一情况，则可能会意外失败：

特定于区域性的数据在 .NET Framework 的主版本或次要版本之间发生更改，或者由于对 .NET Framework 的现有版本进行了更新。
区域性特定的数据反映了用户首选项，这些首选项可能因计算机或会话而异。
区域性特定的数据表示替代区域性，该区域性替代标准区域性或自定义区域性的设置。

为了防止分析与区域性数据更改相关联的数据和时间字符串时出现困难，可以使用固定区域性分析日期和时间字符串，也可以调用 ParseExact 或 TryParseExact 方法并指定要分析的字符串的确切格式。如果要序列化和反序列化日期和时间数据，则可以使用固定区域性的格式设置约定，也可以以二进制格式序列化和反序列化 DateTime 值。

有关详细信息，请参阅 CultureInfo 主题中的“动态区域性数据”部分和 DateTime 主题中的“持久保留 DateTime 值”部分。

分析和样式元素

所有 Parse 重载都忽略输入字符串中的前导、内部或尾随空格字符（由下表中的 s 表示）。日期和时间可以用一对前导和尾随数字符号字符（“#”，U+0023）括起来，并且可以用一个或多个 NULL 字符（U+0000）进行尾随。

此外，Parse(String, IFormatProvider, DateTimeStyles) 重载还有一个 styles 参数，其中包含 DateTimeStyles 枚举的一个或多个成员。此参数定义应如何解释 s 以及如何将分析操作转换为日期和时间 s。下表描述了每个 DateTimeStyles 成员对分析操作的影响。

DateTimeStyles 成员	转换效果
AdjustToUniversal	分析 `s`，如有必要，将其转换为 UTC，如下所示： - 如果 `s` 包含时区偏移量，或者 `s` 不包含时区信息，但 `styles` 包含 AssumeLocal 标志，该方法将分析字符串，调用 ToUniversalTime 将返回的 DateTime 值转换为 UTC，并将 Kind 属性设置为 DateTimeKind.Utc。 - 如果 `s` 指示它表示 UTC，或者如果 `s` 不包含时区信息，但 `styles` 包含 AssumeUniversal 标志，该方法将分析字符串，对返回的 DateTime 值执行时区转换，并将 Kind 属性设置为 DateTimeKind.Utc。 - 在所有其他情况下，标志不起作用。
AllowInnerWhite	忽略此值。始终允许在 `s`的日期和时间元素中使用内部空格。
AllowLeadingWhite	忽略此值。始终允许在 `s`的日期和时间元素中使用前导空格。
AllowTrailingWhite	忽略此值。始终允许在 `s`的日期和时间元素中使用尾随空格。
AllowWhiteSpaces	指定 `s` 可能包含前导空格、内部空格和尾随空格。这是默认行为。它不能通过提供更严格的 DateTimeStyles 枚举值（如 None）来替代它。
AssumeLocal	指定如果 `s` 缺少任何时区信息，则假定为本地时间。除非存在 AdjustToUniversal 标志，否则返回的 DateTime 值的 Kind 属性设置为 DateTimeKind.Local。
AssumeUniversal	指定如果 `s` 缺少任何时区信息，则假定 UTC。除非存在 AdjustToUniversal 标志，否则该方法将返回的 DateTime 值从 UTC 转换为本地时间，并将其 Kind 属性设置为 DateTimeKind.Local。
None	虽然有效，但忽略此值。
RoundtripKind	对于包含时区信息的字符串，尝试防止日期和时间字符串转换为表示本地时间的 DateTime 值，其 Kind 属性设置为 DateTimeKind.Local。通常，此类字符串是通过调用 DateTime.ToString(String) 方法并使用“o”、“r”或“u”标准格式说明符创建的。

返回值和 DateTime.Kind

DateTime.Parse 重载返回 DateTime 值，其 Kind 属性包括时区信息。它可以指示时间为：

协调世界时（System.DateTimeKind.Utc）。
本地时区的时间（System.DateTimeKind.Local）。
未知时区中的时间（System.DateTimeKind.Unspecified）。

通常，Parse 方法返回 Kind 属性 DateTimeKind.Unspecified的 DateTime 对象。但是，Parse 方法还可以执行时区转换，并按不同的方式设置 Kind 属性的值，具体取决于 s 和 styles 参数的值：

如果	时区转换	Kind 属性
`s` 包含时区信息。	日期和时间将转换为本地时区中的时间。	DateTimeKind.Local
`s` 包含时区信息，`styles` 包含 AdjustToUniversal 标志。	日期和时间将转换为协调世界时（UTC）。	DateTimeKind.Utc
`s` 包含 Z 或 GMT 时区设计器，`styles` 包含 RoundtripKind 标志。	日期和时间解释为 UTC。	DateTimeKind.Utc

以下示例将包含时区信息的日期字符串转换为本地时区中的时间：

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

open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"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

还可以使用 DateTimeStyles.RoundtripKind 标志在格式化和分析操作期间保留日期和时间的 Kind 属性的值。以下示例说明 RoundtripKind 标志如何使用“o”、“r”或“u”格式说明符对转换为字符串的 DateTime 值影响分析操作。

   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.

let 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 formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   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)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

使用当前区域性的约定将日期和时间的字符串表示形式转换为其等效 DateTime。

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

包含要转换的日期和时间的字符串。有关详细信息，请参阅要分析的字符串。

DateTime

与 s中包含的日期和时间等效的对象。

例外

ArgumentNullException

snull。

FormatException

s 不包含日期和时间的有效字符串表示形式。

示例

以下示例通过以下方法分析多个日期和时间值的字符串表示形式：

使用默认格式提供程序，该提供程序提供用于生成示例输出的计算机当前区域性的格式约定。此示例的输出反映了 en-US 区域性的格式设置约定。
使用默认样式值，即 AllowWhiteSpaces。

它处理当方法尝试使用其他区域性的格式约定分析日期和时间的字符串表示形式时引发的 FormatException 异常。它还演示如何成功分析不使用当前区域性的格式设置约定的日期和时间值。

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.

open System
open System.Globalization

[<EntryPoint>]
let 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
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{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.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? 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
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

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

注解

如果 s 包含时区信息，此方法将返回一个 DateTime 值，其 Kind 属性 DateTimeKind.Local，并将 s 中的日期和时间转换为本地时间。否则，它不执行时区转换，并返回 Kind 属性 DateTimeKind.Unspecified的 DateTime 值。

此重载尝试使用当前区域性的格式约定分析 s。当前区域性由 CurrentCulture 属性指示。若要使用特定区域性的格式设置约定分析字符串，请调用 Parse(String, IFormatProvider) 或 Parse(String, IFormatProvider, DateTimeStyles) 重载。

此重载尝试使用 DateTimeStyles.AllowWhiteSpaces 样式分析 s。

另请参阅

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

将字符的范围分析为值。

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

参数

s: ReadOnlySpan<Char>

要分析的字符范围。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。

DateTime

分析 s的结果。

实现

Parse(ReadOnlySpan<Char>, IFormatProvider)

适用于

Parse(String, IFormatProvider)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

使用区域性特定的格式信息将日期和时间的字符串表示形式转换为其等效 DateTime。

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;

public static DateTime Parse (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

包含要转换的日期和时间的字符串。有关详细信息，请参阅要分析的字符串。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式信息。请参阅分析和文化约定

DateTime

与由 provider指定的 s 中包含的日期和时间等效的对象。

实现

Parse(String, IFormatProvider)

例外

ArgumentNullException

snull。

FormatException

s 不包含日期和时间的有效字符串表示形式。

示例

以下示例使用 en-US、fr-FR和 de-DE 区域性的约定分析日期字符串数组。它演示了单个日期的字符串表示形式可以在不同的区域性中以不同的方式进行解释。

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.

open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


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

注解

此重载尝试使用 DateTimeStyles.AllowWhiteSpaces 样式分析 s。

另请参阅

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

使用区域性特定的格式信息和格式样式，将包含日期和时间字符串表示形式的内存范围转换为其等效 DateTime。

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, 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 = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

参数

s: ReadOnlySpan<Char>

包含要分析的字符串的内存范围。有关详细信息，请参阅要分析的字符串。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式信息。请参阅分析和文化约定

styles: DateTimeStyles

枚举值的按位组合，指示分析操作成功 s 中可以存在的样式元素，并定义如何解释分析日期相对于当前时区或当前日期。要指定的典型值为 None。

DateTime

一个与 s中包含的日期和时间等效的对象，由 provider 和 styles指定。

例外

FormatException

s 不包含日期和时间的有效字符串表示形式。

ArgumentException

styles 包含 DateTimeStyles 值的无效组合。例如，AssumeLocal 和 AssumeUniversal。

适用于

Parse(String, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

使用区域性特定的格式信息和格式样式将日期和时间的字符串表示形式转换为其等效 DateTime。

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

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

包含要转换的日期和时间的字符串。有关详细信息，请参阅要分析的字符串。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。请参阅分析和文化约定

styles: DateTimeStyles

枚举值的按位组合，指示分析操作成功 s 中可以存在的样式元素，并定义如何解释分析日期相对于当前时区或当前日期。要指定的典型值为 None。

DateTime

一个与 s中包含的日期和时间等效的对象，由 provider 和 styles指定。

例外

ArgumentNullException

snull。

FormatException

s 不包含日期和时间的有效字符串表示形式。

ArgumentException

styles 包含 DateTimeStyles 值的无效组合。例如，AssumeLocal 和 AssumeUniversal。

示例

以下示例演示 Parse(String, IFormatProvider, DateTimeStyles) 方法，并显示生成的 DateTime 值的 Kind 属性的值。

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.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // 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.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

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

注解

此方法重载转换 s 中的日期和时间，并设置返回 DateTime 值的 Kind 属性，如下所示：

如果	时区转换	Kind 属性
`s` 不包含时区信息。	没有。	DateTimeKind.Unspecified
`s` 包含时区信息。	到本地时区的时间	DateTimeKind.Local
`s` 包含时区信息，`styles` 包含 DateTimeStyles.AdjustToUniversal 标志。	协调世界时（UTC）	DateTimeKind.Utc
`s` 包含 Z 或 GMT 时区设计者，`styles` 包括 DateTimeStyles.RoundtripKind。	没有。	DateTimeKind.Utc

另请参阅

适用于

通过

DateTime.Parse 方法

定义

重载

示例

注解

我调用哪种方法？

要分析的字符串

分析和文化约定

分析和样式元素

返回值和 DateTime.Kind

Parse(String)

参数

返回

例外

示例

注解

另请参阅

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider)

参数

返回

实现

适用于

Parse(String, IFormatProvider)

参数

返回

实现

例外

示例

注解

另请参阅

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

参数

返回

例外

适用于

Parse(String, IFormatProvider, DateTimeStyles)

参数

返回

例外

示例

注解

另请参阅

适用于

反馈

其他资源