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)

來源:: DateTimeOffset.cs

來源:: DateTimeOffset.cs

來源:: 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所定義之預期格式的日期和時間，或如果 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 參數所定義。如果 formats 的相符專案是標準格式規範字串，則 input 的精確模式也是如此。 formatProvider 參數可以是下列其中一項：

CultureInfo 物件，表示根據 input 解譯的文化特性。 CultureInfo.DateTimeFormat 屬性所傳回 DateTimeFormatInfo 物件會定義 input中的符號和格式設定。
定義日期和時間數據格式的 DateTimeFormatInfo 物件。

如果 formatprovider 是 null，則會使用對應至目前文化特性的 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)

來源:: DateTimeOffset.cs

來源:: DateTimeOffset.cs

來源:: 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，則會將國際標準時間（UTC）位移或 +00：00 指派給 DateTimeOffset 物件。如果未指定任何值，則會使用當地時區的位移。

input 中使用的特定日期和時間符號和字串是由 formatProvider 參數所定義。如果 format 是標準格式規範字串，則 input 的精確模式也是如此。 formatProvider 參數可以是下列其中一項：

CultureInfo 物件，表示根據 input 解譯的文化特性。 CultureInfo.DateTimeFormat 屬性所傳回的 DateTimeFormatInfo 物件會定義 input中允許的符號和標準格式。
定義日期和時間數據格式的 DateTimeFormatInfo 物件。

如果 formatprovider 是 null，則會使用對應至目前文化特性的 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)

來源:: DateTimeOffset.cs

來源:: DateTimeOffset.cs

來源:: 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，則會將國際標準時間（UTC）位移或 +00：00 指派給 DateTimeOffset 物件。如果未指定任何值，則會使用當地時區的位移。

input 中使用的特定日期和時間符號是由 formatProvider 參數所定義。如果 formats 的相符專案是標準格式規範字串，則 input 的精確模式也是如此。 formatProvider 參數可以是下列其中一項：

CultureInfo 物件，表示根據 input 解譯的文化特性。 CultureInfo.DateTimeFormat 屬性所傳回 DateTimeFormatInfo 物件會定義 input中的符號和格式設定。
定義日期和時間數據格式的 DateTimeFormatInfo 物件。

如果 formatprovider 是 null，則會使用對應至目前文化特性的 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)

來源:: DateTimeOffset.cs

來源:: DateTimeOffset.cs

來源:: 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 值。

範例

下列範例使用 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.

下列範例使用各種值來剖析預期符合 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 物件。

如果 formatprovider 是 null，則會使用對應至目前文化特性的 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)

參數

傳回

例外狀況

範例

備註

給呼叫者的注意事項

另請參閱

適用於

其他資源