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

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 转换不包含日期和时间的有效字符串表示形式，或者不包含所 formats定义的预期格式的日期和时间，或者如果 formats 为 null，则转换失败。此参数未初始化传递。

Boolean

如果成功转换参数，则为。

例外

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。如果未指定这两个值，则使用本地时区的偏移量。

参数定义了formatProvider用于input的特定日期和时间符号和字符串。如果匹配元素formats是标准格式说明符字符串，则同样如此input。该 formatProvider 参数可以是下列任一参数：

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

null如果是formatprovider，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	由于结构不包含`Kind`属性，因此不起作用DateTimeOffset。

调用方说明

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

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

如果成功转换参数，则为。

例外

ArgumentException

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

注解

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

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

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

参数定义了formatProvider用于input的特定日期和时间符号和字符串。对于是否format为标准格式说明符字符串的input精确模式也是如此。该 formatProvider 参数可以是下列任一参数：

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

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

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

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

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

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

Boolean

如果成功转换参数，则为。

例外

ArgumentException

styles 包括未定义 DateTimeStyles 的值。 -or- 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。如果未指定这两个值，则使用本地时区的偏移量。

参数定义了formatProvider所使用的input特定日期和时间符号。如果匹配元素formats是标准格式说明符字符串，则同样如此input。该 formatProvider 参数可以是下列任一参数：

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

null如果是formatprovider，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	由于结构不包含`Kind`属性，因此不起作用DateTimeOffset。

适用于

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

Source:: DateTimeOffset.cs

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

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

Boolean

如果成功转换参数，则为。

例外

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或zzzzz自定义格式说明符以指示偏移必须存在于input其中，则偏移必须包含负号或正号。如果缺少符号，分析操作将失败，并且该方法返回 false。

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

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

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

参数

返回

例外

示例

注解

调用方说明

另请参阅

适用于

反馈