DateTime.Parse 方法

定义

命名空间:: System

程序集:: mscorlib.dll, System.Runtime.dll

程序集:: netstandard.dll, System.Runtime.dll

程序集:: 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都插在一起。

还可以下载一组 DateTime.Parse 完整的示例，这些示例包含在适用于 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) 方法，并使用调用 Parse(String, IFormatProvider, DateTimeStyles) 重载 DateTimeStyles.RoundtripKind
跨计算机（甚至区域性）边界以固定格式分析日期和时间字符串。	DateTime.ParseExact 或 DateTime.TryParseExact 方法

要分析的字符串

该方法 Parse 尝试将日期和时间值的字符串表示形式转换为等效 DateTime 值。它尝试完全分析输入字符串，而不会引发 FormatException 异常。使用接受对象的 IFormatProvider 重载时，它将用于分析 StringToParse。如果未提供此类对象， CurrentCulture 将改用。

重要

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

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

包含日期和时间组件的字符串。
包含日期但没有时间组件的字符串。如果时间组件不存在，则该方法假定午夜为 12：00。如果日期组件具有两位数的年份，则会根据 Calendar.TwoDigitYearMax 当前区域性的当前日历或指定区域性的当前日历（如果使用具有非 null provider 参数的重载）转换为年份。
包含仅包含月份和年份但不包含日期组件的字符串。该方法假定月份的第一天。
包含仅包含月份和日期但不包含年份组件的日期组件的字符串。该方法假定当前年份。
具有时间但无日期组件的字符串。该方法假定当前日期，除非调用 Parse(String, IFormatProvider, DateTimeStyles) 重载并包含在 DateTimeStyles.NoCurrentDateDefault 自变量中 styles ，在这种情况下，该方法假定日期为 0001 年 1 月 1 日。
包含仅包含小时和 AM/PM 设计符的时间组件的字符串，不包含日期组件。该方法假定当前日期和时间，不带分钟和秒。可以通过调用 Parse(String, IFormatProvider, DateTimeStyles) 重载并包含在 DateTimeStyles.NoCurrentDateDefault 参数中 styles 来更改此行为，在这种情况下，该方法假定日期为 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标记存在，否则返回值Kind的DateTime属性将设置为DateTimeKind.Local。
AssumeUniversal	指定如果 `s` 缺少任何时区信息，则假定采用 UTC。除非存在AdjustToUniversal标志，否则该方法会将返回的DateTime值从 UTC 转换为本地时间，并设置其Kind属性为DateTimeKind.Local。
None	虽然有效，但忽略此值。
RoundtripKind	对于包含时区信息的字符串，尝试阻止将日期和时间字符串DateTime转换为表示其属性设置为DateTimeKind.Local的本地时间Kind的值。通常，此类字符串是通过调用 DateTime.ToString(String) 方法并使用“o”、“r”或“u”标准格式说明符创建的。

返回值和 DateTime.Kind

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

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

通常，该方法 Parse 返回 DateTime 其 Kind 属性为 DateTimeKind.Unspecified.. 但是，该方法 Parse 还可以执行时区转换，并根据参数的值以不同的方式设置属性的值 Kindsstyles ：

如果	时区转换	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

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

s 是 null。

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转换为本地时间。否则，它不执行时区转换，并返回 DateTime 其 Kind 属性为 DateTimeKind.Unspecified的值。

此重载尝试 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

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

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

s 是 null。

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

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指定的providerstyles日期和时间。

例外

FormatException

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

ArgumentException

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

适用于

Parse(String, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

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指定的providerstyles日期和时间。

例外

ArgumentNullException

s 是 null。

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

另请参阅

适用于

反馈

此页面是否有帮助？