DateTimeOffset.TryParseExact 方法

参考

定义

命名空间:: System

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

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

程序集:: 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

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

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

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，则向 DateTimeOffset 对象分配协调世界时（UTC）偏移量或 +00：00。如果未指定这两个值，则使用本地时区的偏移量。

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

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

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

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

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input`，并在必要时将其转换为 UTC。它等效于分析字符串，然后调用返回 DateTimeOffset 对象的 DateTimeOffset.ToUniversalTime 方法。
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 中，如果要分析的字符串包含一小时组件和未达成协议的 AM/PM 指示符，则 TryParseExact 返回 false。在 .NET Framework 3.5 及更早版本中，将忽略 AM/PM 设计器。

适用于

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

Source:: DateTimeOffset.cs

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

此方法返回时，包含与 input日期和时间等效的 DateTimeOffset（如果转换成功）或 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，则向 DateTimeOffset 对象分配协调世界时（UTC）偏移量或 +00：00。如果未指定这两个值，则使用本地时区的偏移量。

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

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

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

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input`，并在必要时将其转换为 UTC。它等效于分析日期和时间表示形式，然后调用返回 DateTimeOffset 对象的 DateTimeOffset.ToUniversalTime 方法。
AssumeLocal	如果 `format` 不需要 `input` 包含偏移值，则返回的 DateTimeOffset 对象将得到本地时区的偏移量。这是默认行为。
AssumeUniversal	如果 `format` 不需要 `input` 包含偏移值，则返回的 DateTimeOffset 对象将获得 UTC 偏移量（+00：00）。
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

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

此方法返回时，包含与 input日期和时间等效的 DateTimeOffset（如果转换成功）或 DateTimeOffset.MinValue（如果转换失败）。如果转换失败

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，则向 DateTimeOffset 对象分配协调世界时（UTC）偏移量或 +00：00。如果未指定这两个值，则使用本地时区的偏移量。

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

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

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

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input`，并在必要时将其转换为 UTC。它等效于分析字符串，然后调用返回 DateTimeOffset 对象的 DateTimeOffset.ToUniversalTime 方法。
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

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

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

Boolean

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

例外

ArgumentException

styles 包括未定义的 DateTimeStyles 值。

-或-

不支持 NoCurrentDateDefault。

-或-

styles 包括互斥 DateTimeStyles 值。

示例

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

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.

以下示例使用各种值来分析一组字符串，这些字符串应符合 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 解释区域性。 CultureInfo.DateTimeFormat 属性返回的 DateTimeFormatInfo 对象定义 input中允许的符号和标准格式。
定义日期和时间数据格式的 DateTimeFormatInfo 对象。

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

`DateTimeStyles` 成员	行为
AdjustToUniversal	分析 `input`，并在必要时将其转换为 UTC。它等效于分析字符串，然后调用返回 DateTimeOffset 对象的 DateTimeOffset.ToUniversalTime 方法。
AssumeLocal	如果 `format` 不需要 `input` 包含偏移值，则返回的 DateTimeOffset 对象将得到本地时区的偏移量。这是默认行为。
AssumeUniversal	如果 `format` 不需要 `input` 包含偏移值，则返回的 DateTimeOffset 对象将获得 UTC 偏移量（+00：00）。
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)

参数

返回

例外

示例

注解

调用方说明

另请参阅

适用于

反馈