DateTimeOffset.TryParseExact 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

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

将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。字符串表示形式的格式必须与指定的格式完全匹配。

重载

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	使用指定的格式数组、区域性特定格式信息和样式，将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。字符串表示形式的格式必须与一种指定的格式完全匹配。
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。日期和时间表示形式的格式必须与指定的格式完全匹配。
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。日期和时间表示形式的格式必须与一种指定的格式完全匹配。
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)	使用指定的格式、区域性特定的格式信息和样式将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。字符串表示形式的格式必须与指定的格式完全匹配。

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

使用指定的格式数组、区域性特定格式信息和样式，将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。字符串表示形式的格式必须与一种指定的格式完全匹配。

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

参数

input: String

包含要转换的日期和时间的字符串。

formats: String[]

一个用于定义 input 的所需格式的数组。

formatProvider: IFormatProvider

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

styles: DateTimeStyles

枚举值的一个按位组合，指示输入所允许的格式。要指定的一个典型值为 None。

result: DateTimeOffset

当方法返回时，如果转换成功，则 DateTimeOffset 包含等效于 input的日期和时间;如果转换失败，则包含 DateTimeOffset.MinValue。如果 input 不包含日期和时间的有效字符串表示形式，或者不包含 format 所定义的所需格式的日期和时间，或者 formats 为 null，则转换失败。此参数未经初始化即被传递。

Boolean

如果 input 参数成功转换，则为 true；否则为 false。

例外

ArgumentException

styles 包括未定义的 DateTimeStyles 值。

- 或 -

不支持 NoCurrentDateDefault。

- 或 -

styles 包括互斥的 DateTimeStyles 值。

示例

以下示例为日期和时间以及偏移值的字符串表示形式定义多种输入格式，然后将用户输入的字符串传递给 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) 方法。

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

注解

方法 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) 分析与分配给 formats 数组的任何一种模式匹配的日期的字符串表示形式。 input如果字符串与参数定义styles的任何变体的这些模式中的任何一个都不匹配，则分析操作将失败，并且该方法返回 false。除了与包含格式说明符的多个字符串进行比较 input 外，此重载的行为与方法相同 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 。

参数 formats 是一个字符串数组，其元素包含一个标准格式说明符或一个或多个定义的可能模式的 input自定义格式说明符。有关有效格式设置代码的详细信息，请参阅标准日期和时间格式字符串和自定义日期和时间格式字符串。如果中的 formats 匹配元素包括 z、 zz或 zzz 自定义格式说明符，以指示偏移必须存在于中 input，则偏移量必须包含负号或正号。如果缺少符号，则分析操作将失败，并且该方法返回 false。

重要

formats使用此重载的参数指定多种格式有助于减少许多用户在输入日期和时间时遇到的挫折感。具体而言，定义多个输入模式的功能使应用程序能够处理日期和时间表示形式，这些表示形式可以包括或缺少月份、天、小时、分钟和秒的前导零。该示例对此进行了说明。

如果中的 formats 匹配元素需要 input 包含日期而不是时间，则为生成的 DateTimeOffset 对象分配午夜时间 (0：00：00) 。如果中的 formats 匹配元素要求输入包含时间而不是日期，则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。如果中的 formats 匹配元素不需要 input 包含偏移量，则生成的 DateTimeOffset 对象的偏移量取决于参数的值 styles 。如果 styles 包含 AssumeLocal，则会将本地时区的偏移量分配给对象 DateTimeOffset 。如果 styles 包含 AssumeUniversal，则会将协调世界时 (UTC) 偏移量或 +00：00 分配给对象 DateTimeOffset 。如果两个值均未指定，则使用本地时区的偏移量。

中 input 使用的特定日期和时间符号和字符串由 formatProvider 参数定义。如果的inputformats匹配元素是标准格式说明符字符串，则对于的精确模式也是如此。参数 formatProvider 可以是以下任一参数：

一个 CultureInfo 对象，该对象表示解释所基于的 input 区域性。 DateTimeFormatInfo属性CultureInfo.DateTimeFormat返回的对象定义中的input符号和格式。
一个 DateTimeFormatInfo 定义日期和时间数据格式的对象。

如果 formatprovider 为 null，则 CultureInfo 使用与当前区域性对应的对象。

参数 styles 定义是否允许在输入字符串中使用空格，指示如何分析没有显式偏移量的字符串，并支持 UTC 转换作为分析操作的一部分。支持枚举的所有成员 DateTimeStyles ，但除外 NoCurrentDateDefault。下表列出了每个受支持成员的效果。

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input` 并在必要时将其转换为 UTC。它等效于分析字符串，然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的对象的方法。
AssumeLocal	如果中的 `formats` 匹配元素不需要 `input` 包含偏移值，则会为返回 DateTimeOffset 的对象提供本地时区的偏移量。这是默认值。
AssumeUniversal	如果中的 `formats` 匹配元素不需要 `input` 包含偏移值，则会为返回 DateTimeOffset 的对象提供 UTC 偏移量 (+00：00) 。
AllowInnerWhite	允许 `input` 包含中元素 `formats`未指定的内部空白。除了偏移) 之外，日期和时间组件之间以及各个组件 (中可能会出现额外的空格，分析字符串时会忽略。
AllowLeadingWhite	允许 `input` 包含中 `formats`元素未指定的前导空格。分析字符串时，这些将被忽略。
AllowTrailingWhite	允许 `input` 包含中 `formats`元素未指定的尾随空格。分析字符串时，这些将被忽略。
AllowWhiteSpaces	允许 `input` 包含中元素 `formats`未指定的前导、尾随和内部空格。分析字符串时，将忽略中 `formats` 匹配元素中未指定的所有额外空白字符。
None	指示中不允许使用 `input`额外的空格。空白必须完全按照中的 `formats` 特定元素中的指定显示，才能成功匹配。此选项为默认行为。
RoundtripKind	不起作用， DateTimeOffset 因为结构不包含 `Kind` 属性。

调用方说明

在.NET Framework 4 中，TryParseExact如果要分析的字符串包含一个小时分量和一个不一致 AM/PM 指示符，则返回 false 。在 .NET Framework 3.5 及更早版本中，将忽略 AM/PM 指示符。

适用于

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。日期和时间表示形式的格式必须与指定的格式完全匹配。

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

参数

input: ReadOnlySpan<Char>

一个范围，包含表示要转换的日期和时间的字符。

format: ReadOnlySpan<Char>

用于定义所需的 input 格式的格式说明符。

formatProvider: IFormatProvider

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

styles: DateTimeStyles

枚举值的一个按位组合，指示 input 所允许的格式。要指定的一个典型值为 None。

result: DateTimeOffset

当方法返回时，如果转换成功，则 DateTimeOffset 包含与的日期和时间等效的 input;如果转换失败，则包含 DateTimeOffset.MinValue 。如果出现以下情况，转换将失败

Boolean

如果 input 参数成功转换，则为 true；否则为 false。

例外

ArgumentException

styles 包括未定义的 DateTimeStyles 值。 -或- NoCurrentDateDefault 不受支持。 -或- styles 包括相互排斥的 DateTimeStyles 值。

注解

此重载类似于 DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 方法，只不过此方法在转换失败时不会引发异常。它分析必须与参数指定的模式完全匹配的日期和时间的 format 表示形式。如果 input 与此模式不匹配，并且参数定义了 styles 一些可能的空格变化，则分析操作将失败，方法返回 false。

参数 format 是包含单个标准格式说明符或一个或多个定义所需模式的自定义格式说明符的 input字符范围。有关有效格式设置代码的详细信息，请参阅标准日期和时间格式字符串和自定义日期和时间格式字符串。如果 format 包含 z、 zz或 zzz 自定义格式说明符来指示偏移必须存在于中 input，则偏移量必须包含负号或正号。如果缺少符号，则分析操作将失败，并且该方法返回 false。

如果需要 format 包含 input 日期而不是时间，则为生成的 DateTimeOffset 对象分配午夜时间 (0：00：00) 。如果需要 format 包含 input 时间而不是日期，则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。如果 format 不需要包含 input 偏移量，则生成的 DateTimeOffset 对象的偏移量取决于参数的值 styles 。如果 styles 包含 AssumeLocal，则会将本地时区的偏移量分配给对象 DateTimeOffset 。如果 styles 包含 AssumeUniversal，则会将协调世界时 (UTC) 偏移量或 +00：00 分配给对象 DateTimeOffset 。如果两个值均未指定，则使用本地时区的偏移量。

中 input 使用的特定日期和时间符号和字符串由 formatProvider 参数定义。如果 format 是标准格式说明符字符串，则对于的精确模式input也是如此。参数 formatProvider 可以是以下任一参数：

一个 CultureInfo 对象，该对象表示解释所基于的 input 区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的对象定义中input允许的符号和标准格式。
一个 DateTimeFormatInfo 定义日期和时间数据格式的对象。

如果 formatprovider 为 null，则 CultureInfo 使用与当前区域性对应的对象。

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input` 并在必要时将其转换为 UTC。它等效于分析日期和时间表示形式，然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的对象的方法。
AssumeLocal	如果 `format` 不需要包含 `input` 偏移值的，则返回 DateTimeOffset 的对象将被赋予本地时区的偏移量。此选项为默认行为。
AssumeUniversal	如果 `format` 不需要包含 `input` 偏移值，则返回 DateTimeOffset 的对象) (+00：00 的 UTC 偏移量。
AllowInnerWhite	允许 `input` 包含未按格式指定的内部空格。除了偏移量，还可以在日期和时间组件之间以及各个组件内显示额外的空格，并在分析字符串时被忽略。
AllowLeadingWhite	允许 `input` 包含未指定的 `format`前导空格。分析字符串时，这些将被忽略。
AllowTrailingWhite	允许 `input` 包含未指定的 `format`尾随空格。分析字符串时，这些将被忽略。
AllowWhiteSpaces	允许 `input` 包含未指定的 `format`前导空格、尾随空格和内部空格。分析字符串时，将忽略中 `format` 未指定的所有额外空白字符。
None	指示中不允许使用 `input`额外的空格。空白必须完全按照中的 `format`指定显示。此选项为默认行为。
RoundtripKind	不起作用，因为 DateTimeOffset 结构不包含 `Kind` 属性。

适用于

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

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

使用指定的格式、区域性特定的格式信息和样式将字符范围中的日期和时间的表示形式转换为其等效的 DateTimeOffset。日期和时间表示形式的格式必须与一种指定的格式完全匹配。

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

参数

input: ReadOnlySpan<Char>

一个范围，包含表示要转换的日期和时间的字符。

formats: String[]

用于定义可接受的 input 格式的标准或自定义格式字符串的数组。

formatProvider: IFormatProvider

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

styles: DateTimeStyles

枚举值的一个按位组合，指示 input 所允许的格式。要指定的一个典型值为 None。

result: DateTimeOffset

Boolean

如果 input 参数成功转换，则为 true；否则为 false。

例外

ArgumentException

styles 包括未定义的 DateTimeStyles 值。 -或- NoCurrentDateDefault 不受支持。 -或- styles 包括相互排斥的 DateTimeStyles 值。

注解

此方法分析与分配给数组的任何一种模式匹配的日期的 formats 字符串表示形式。如果 input 与参数定义 styles 的任何变体中的任一模式不匹配，则分析操作将失败，并且方法返回 false。除了与包含格式说明符的多个字符串进行比较 input 外，此重载的行为与方法相同 DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) 。

重要

如果中的 formats 匹配元素需要 input 包含日期而不是时间，则为生成的 DateTimeOffset 对象分配午夜时间 (0：00：00) 。如果中的 formats 匹配元素要求输入包含时间而不是日期，则为生成的 DateTimeOffset 对象分配本地系统上的当前日期。如果中的 formats 匹配元素不需要 input 包含偏移量，则生成的 DateTimeOffset 对象的偏移量取决于参数的值 styles 。如果 styles 包含 DateTimeStyles.AssumeLocal，则会将本地时区的偏移量分配给对象 DateTimeOffset 。如果 styles 包含 DateTimeStyles.AssumeUniversal，则会将协调世界时 (UTC) 偏移量或 +00：00 分配给对象 DateTimeOffset 。如果两个值均未指定，则使用本地时区的偏移量。

中使用的 input 特定日期和时间符号由 formatProvider 参数定义。如果的inputformats匹配元素是标准格式说明符字符串，则对于的精确模式也是如此。参数 formatProvider 可以是以下任一参数：

一个 CultureInfo 对象，该对象表示解释所基于的 input 区域性。 DateTimeFormatInfo属性CultureInfo.DateTimeFormat返回的对象定义中的input符号和格式。
一个 DateTimeFormatInfo 定义日期和时间数据格式的对象。

如果 formatprovider 为 null，则 CultureInfo 使用与当前区域性对应的对象。

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input` 并在必要时将其转换为 UTC。它等效于分析字符串，然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的对象的方法。
AssumeLocal	如果中的 `formats` 匹配元素不需要 `input` 包含偏移值，则会为返回 DateTimeOffset 的对象提供本地时区的偏移量。这是默认值。
AssumeUniversal	如果中的 `formats` 匹配元素不需要 `input` 包含偏移值，则会为返回 DateTimeOffset 的对象提供 UTC 偏移量 (+00：00) 。
AllowInnerWhite	允许 `input` 包含中元素 `formats`未指定的内部空白。除了偏移) 之外，日期和时间组件之间以及各个组件 (中可能会出现额外的空格，分析字符串时会忽略。
AllowLeadingWhite	允许 `input` 包含中 `formats`元素未指定的前导空格。分析字符串时，这些将被忽略。
AllowTrailingWhite	允许 `input` 包含中 `formats`元素未指定的尾随空格。分析字符串时，这些将被忽略。
AllowWhiteSpaces	允许 `input` 包含中元素 `formats`未指定的前导、尾随和内部空格。分析字符串时，将忽略中 `formats` 匹配元素中未指定的所有额外空白字符。
None	指示中不允许使用 `input`额外的空格。空白必须完全按照中的 `formats` 特定元素中的指定显示，才能成功匹配。此选项为默认行为。
RoundtripKind	不起作用， DateTimeOffset 因为结构不包含 `Kind` 属性。

适用于

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

使用指定的格式、区域性特定的格式信息和样式将日期和时间的指定字符串表示形式转换为其等效的 DateTimeOffset。字符串表示形式的格式必须与指定的格式完全匹配。

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);

public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);

static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool

Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

参数

input: String

包含要转换的日期和时间的字符串。

format: String

用于定义所需的 input 格式的格式说明符。

formatProvider: IFormatProvider

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

styles: DateTimeStyles

枚举值的一个按位组合，指示输入所允许的格式。要指定的一个典型值为 None。

result: DateTimeOffset

当方法返回时，如果转换成功，则 DateTimeOffset 包含等效于 input的日期和时间;如果转换失败，则包含 DateTimeOffset.MinValue。如果 input 参数为 null，或者不包含 format 和 provider所定义的所需格式的日期和时间的有效字符串表示形式，则转换失败。此参数未经初始化即被传递。

Boolean

如果 input 参数成功转换，则为 true；否则为 false。

例外

ArgumentException

styles 包括未定义的 DateTimeStyles 值。

- 或 -

不支持 NoCurrentDateDefault。

- 或 -

styles 包括互斥的 DateTimeStyles 值。

示例

以下示例使用 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) 方法以及标准和自定义格式说明符、固定区域性和各种 DateTimeStyles 值来分析多个日期和时间字符串。

string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AssumeUniversal,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                   DateTimeStyles.AssumeUniversal, _
                                   result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

以下示例使用各种 DateTimeStyles 值来分析应符合 ISO 8601 的字符串数组。如示例输出所示，如果出现以下情况，则无法分析格式正确的字符串：

它们包含空格，并且方法调用中未提供相应的 DateTimeStyles 标志 (，例如 DateTimeStyles.AllowWhiteSpaces 。
它们包含的日期和时间元素在范围外。

假定未指定 UTC 偏移量的字符串具有本地时区的偏移量 (在本例中为 -07：00，这将反映太平洋夏令时时区) 的偏移量，除非 DateTimeStyles.AssumeUniversal 在方法调用中提供了标志。在这种情况下，它们假定为世界协调时。

open System
open System.Globalization

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
        | true, date ->
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        | _ ->
            printfn $"   Unable to convert '{dateString}'"

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

注解

方法的 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) 此重载与方法类似 DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) ，只不过此方法在转换失败时不会引发异常。它分析日期和时间的字符串表示形式，该日期和时间必须与参数指定的 format 模式完全匹配。 input如果字符串与此模式不匹配，并且参数定义了styles一些可能的空格变化，则分析操作将失败，并且该方法返回 false。

参数 format 是一个字符串，其中包含一个标准格式说明符或一个或多个定义所需模式的 input自定义格式说明符。有关有效格式设置代码的详细信息，请参阅标准日期和时间格式字符串和自定义日期和时间格式字符串。如果 format 包含 z、 zz或 zzz 自定义格式说明符来指示偏移必须存在于中 input，则偏移量必须包含负号或正号。如果缺少符号，则分析操作将失败，并且该方法返回 false。

一个 CultureInfo 对象，该对象表示解释所基于的 input 区域性。 DateTimeFormatInfo属性返回CultureInfo.DateTimeFormat的对象定义中input允许的符号和标准格式。
一个 DateTimeFormatInfo 定义日期和时间数据格式的对象。

如果 formatprovider 为 null，则 CultureInfo 使用与当前区域性对应的对象。

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input` 并在必要时将其转换为 UTC。它等效于分析字符串，然后调用 DateTimeOffset.ToUniversalTime 返回 DateTimeOffset 的对象的方法。
AssumeLocal	如果 `format` 不需要包含 `input` 偏移值的，则返回 DateTimeOffset 的对象将被赋予本地时区的偏移量。此选项为默认行为。
AssumeUniversal	如果 `format` 不需要包含 `input` 偏移值，则返回 DateTimeOffset 的对象) (+00：00 的 UTC 偏移量。
AllowInnerWhite	允许 `input` 包含未按格式指定的内部空格。除了偏移量，还可以在日期和时间组件之间以及各个组件内显示额外的空格，并在分析字符串时被忽略。
AllowLeadingWhite	允许 `input` 包含未指定的 `format`前导空格。分析字符串时，这些将被忽略。
AllowTrailingWhite	允许 `input` 包含未指定的 `format`尾随空格。分析字符串时，这些将被忽略。
AllowWhiteSpaces	允许 `input` 包含未指定的 `format`前导空格、尾随空格和内部空格。分析字符串时，将忽略中 `format` 未指定的所有额外空白字符。
None	指示中不允许使用 `input`额外的空格。空白必须完全按照中的 `format`指定显示。此选项为默认行为。
RoundtripKind	不起作用，因为 DateTimeOffset 结构不包含 `Kind` 属性。

调用方说明

另请参阅

ParseExact

适用于

DateTimeOffset.TryParseExact 方法

定义

重载

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

参数

返回

例外

示例

注解

调用方说明

适用于

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

参数

返回

例外

注解

适用于

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

参数

返回

例外

注解

适用于

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

参数

返回

例外

示例

注解

调用方说明

另请参阅

适用于

反馈

其他资源