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

メソッドから制御が戻るときに、変換に成功した場合はの日時に相当するを格納し、変換に失敗した場合は 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 パラメーターは、要素に 1 つの標準書式指定子または 1 つ以上のカスタム書式指定子を含み、inputのパターンを定義する文字列配列です。有効な書式設定コードの詳細については、「標準の日付と時刻の書式指定文字列」および「カスタム日時書式指定文字列する」を参照してください。 formats の一致する要素に、オフセットが inputに存在する必要があることを示す z、zz、または zzz カスタム書式指定子が含まれている場合、そのオフセットには負符号または正符号が含まれている必要があります。符号が見つからない場合、解析操作は失敗し、メソッドは falseを返します。

大事な

このオーバーロードの formats パラメーターを使用して複数の形式を指定すると、多くのユーザーが日付と時刻を入力するときの不満を軽減できます。特に、複数の入力パターンを定義する機能により、アプリケーションは、月、日、時間、分、秒の先頭のゼロを含めたり欠けたりする日付と時刻の表現を処理できます。この例では、この図を示します。

formats の一致する要素で、input に日付は含まれている必要がありますが、時刻が含まれていない場合、結果の DateTimeOffset オブジェクトには午前 0 時 (0:00:00) の時刻が割り当てられます。 formats の一致する要素に日付ではなく時刻を入力する必要がある場合、結果の DateTimeOffset オブジェクトにはローカルシステムの現在の日付が割り当てられます。 formats の一致する要素にオフセット input 含まれている必要がない場合、結果の DateTimeOffset オブジェクトのオフセットは、styles パラメーターの値によって異なります。 styles AssumeLocalが含まれている場合、ローカルタイムゾーンのオフセットが DateTimeOffset オブジェクトに割り当てられます。 styles に AssumeUniversalが含まれている場合、協定世界時 (UTC) オフセット (+00:00) が DateTimeOffset オブジェクトに割り当てられます。どちらの値も指定されていない場合は、ローカルタイムゾーンのオフセットが使用されます。

input で使用される特定の日時記号と文字列は、formatProvider パラメーターによって定義されます。 formats の一致する要素が標準の書式指定子文字列である場合、input の正確なパターンについても同じことが当てはまります。 formatProvider パラメーターには、次のいずれかを指定できます。

解釈される input に基づいてカルチャを表す CultureInfo オブジェクト。 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	`formats`内の要素で指定されていない先頭のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
AllowTrailingWhite	`input` `formats`内の要素で指定されていない末尾のスペースを含めることができます。文字列を解析する場合、これらは無視されます。
AllowWhiteSpaces	`formats`の要素で指定されていない先頭、末尾、および内側のスペースを `input` に含めることができます。文字列の解析時に、`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

メソッドから制御が戻るときに、変換に成功した場合はの日時に相当する、変換に失敗した場合は 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 パラメーターは、1 つの標準書式指定子、または inputの必要なパターンを定義する 1 つ以上のカスタム書式指定子を含む文字スパンです。有効な書式設定コードの詳細については、「標準の日付と時刻の書式指定文字列」および「カスタム日時書式指定文字列する」を参照してください。 format z、zz、またはカスタム書式指定子を含み、オフセットが zzzinputに存在する必要があることを示す場合、そのオフセットには負符号または正符号を含める必要があります。符号が見つからない場合、解析操作は失敗し、メソッドは false返します。

format input 日付を含む必要があるが、時刻が含まれていない場合、結果の DateTimeOffset オブジェクトには午前 0 時 (0:00:00) の時刻が割り当てられます。 format input に日付ではなく時刻を含む必要がある場合、結果の DateTimeOffset オブジェクトにはローカルシステムの現在の日付が割り当てられます。 format input にオフセットを含む必要がない場合、結果の DateTimeOffset オブジェクトのオフセットは、styles パラメーターの値によって異なります。 styles AssumeLocalが含まれている場合、ローカルタイムゾーンのオフセットが DateTimeOffset オブジェクトに割り当てられます。 styles に AssumeUniversalが含まれている場合、協定世界時 (UTC) オフセット (+00:00) が DateTimeOffset オブジェクトに割り当てられます。どちらの値も指定されていない場合は、ローカルタイムゾーンのオフセットが使用されます。

input で使用される特定の日時記号と文字列は、formatProvider パラメーターによって定義されます。 format が標準書式指定子文字列の場合、input の正確なパターンについても同様です。 formatProvider パラメーターには、次のいずれかを指定できます。

解釈される input に基づいてカルチャを表す CultureInfo オブジェクト。 CultureInfo.DateTimeFormat プロパティによって返される DateTimeFormatInfo オブジェクトは、inputで使用できるシンボルと標準形式を定義します。
日付と時刻のデータの形式を定義する DateTimeFormatInfo オブジェクト。

formatprovider が nullされている場合は、現在のカルチャに対応する CultureInfo オブジェクトが使用されます。

styles パラメーターは、入力文字列で空白を使用できるかどうかを定義し、明示的なオフセットコンポーネントのない文字列の解析方法を示し、解析操作の一部として UTC 変換をサポートします。 NoCurrentDateDefaultを除き、DateTimeStyles 列挙体のすべてのメンバーがサポートされています。次の表に、サポートされている各メンバーの効果を示します。

`DateTimeStyles` メンバー	振舞い
AdjustToUniversal	`input` を解析し、必要に応じて UTC に変換します。これは、日付と時刻の表現を解析し、返された DateTimeOffset オブジェクトの DateTimeOffset.ToUniversalTime メソッドを呼び出すことと同じです。
AssumeLocal	`format` `input` にオフセット値が含まれている必要がない場合、返される DateTimeOffset オブジェクトにはローカルタイムゾーンのオフセットが与えられます。これが既定の動作です。
AssumeUniversal	`format` `input` オフセット値を含む必要がない場合、返される DateTimeOffset オブジェクトには UTC オフセット (+00:00) が与えられます。
AllowInnerWhite	`input` に、形式で指定されていない内側の空白を含めることができます。日付と時刻のコンポーネント間、およびオフセット以外の個々のコンポーネント内に余分な空白が表示される可能性があり、文字列の解析時には無視されます。
AllowLeadingWhite	`format`で指定されていない先頭のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
AllowTrailingWhite	`format`で指定されていない末尾のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
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

戻り値

Boolean

input パラメーターが正常に変換されたかどうかを true します。それ以外の場合は、falseします。

例外

ArgumentException

注釈

このメソッドは、formats 配列に割り当てられているパターンのいずれかに一致する日付の文字列表現を解析します。 input styles パラメーターによって定義されたバリエーションとこれらのパターンのいずれかが一致しない場合、解析操作は失敗し、メソッドは falseを返します。書式指定子を含む複数の文字列と input を比較する以外に、このオーバーロードは DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) メソッドと同じように動作します。

大事な

formats の一致する要素で、input に日付は含まれている必要がありますが、時刻が含まれていない場合、結果の DateTimeOffset オブジェクトには午前 0 時 (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 パラメーターには、次のいずれかを指定できます。

解釈される input に基づいてカルチャを表す CultureInfo オブジェクト。 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	`formats`内の要素で指定されていない先頭のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
AllowTrailingWhite	`input` `formats`内の要素で指定されていない末尾のスペースを含めることができます。文字列を解析する場合、これらは無視されます。
AllowWhiteSpaces	`formats`の要素で指定されていない先頭、末尾、および内側のスペースを `input` に含めることができます。文字列の解析時に、`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

メソッドから制御が戻るときに、変換に成功した場合はの日時に相当するを格納し、変換に失敗した場合は 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.

次の例では、さまざまな DateTimeStyles 値を使用して、ISO 8601に準拠することが期待される文字列の配列を解析します。この例の出力が示すように、適切な形式の文字列は、次の場合に解析に失敗します。

空白が含まれており、適切な DateTimeStyles フラグ (DateTimeStyles.AllowWhiteSpaces など) がメソッド呼び出しで指定されていません。
これらの要素には、範囲外の日付と時刻の要素が含まれています。

UTC オフセットを指定しない文字列は、メソッド呼び出しで DateTimeStyles.AssumeUniversal フラグが指定されていない限り、ローカルタイムゾーンのオフセット (この場合は -07:00、太平洋夏時間ゾーンのオフセットを反映) を持つものと見なされます。その場合、それらは世界協定時刻と見なされます。

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 パラメーターは、1 つの標準書式指定子または 1 つ以上のカスタム書式指定子を含む文字列で、inputの必要なパターンを定義します。有効な書式設定コードの詳細については、「標準の日付と時刻の書式指定文字列」および「カスタム日時書式指定文字列する」を参照してください。 format z、zz、またはカスタム書式指定子を含み、オフセットが zzzinputに存在する必要があることを示す場合、そのオフセットには負符号または正符号を含める必要があります。符号が見つからない場合、解析操作は失敗し、メソッドは false返します。

解釈される input に基づいてカルチャを表す CultureInfo オブジェクト。 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	`format`で指定されていない先頭のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
AllowTrailingWhite	`format`で指定されていない末尾のスペースを `input` に含めることができます。文字列を解析する場合、これらは無視されます。
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)

パラメーター

戻り値

例外

例

注釈

注意 (呼び出し元)

こちらもご覧ください

適用対象

フィードバック

その他のリソース