DateTimeOffset.TryParseExact Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTimeOffset. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

Przeciążenia

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTimeOffset przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	Konwertuje reprezentację daty i godziny w zakresie znaków na jego DateTimeOffset odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji daty i godziny musi być dokładnie zgodny z określonym formatem.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)	Konwertuje reprezentację daty i godziny w zakresie znaków na jego DateTimeOffset odpowiednik przy użyciu określonych formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji daty i godziny musi być dokładnie zgodny z jednym z określonych formatów.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)	Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTimeOffset przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTimeOffset przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input: String

Ciąg zawierający datę i godzinę do przekonwertowania.

formats: String[]

Tablica, która definiuje oczekiwane formaty input.

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat input.

styles: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format danych wejściowych. Typową wartością do określenia jest None.

result: DateTimeOffset

Gdy metoda zwraca wartość , zawiera DateTimeOffset równoważną dacie i godzinie input, jeśli konwersja zakończyła się pomyślnie lub DateTimeOffset.MinValue, jeśli konwersja nie powiodła się. Konwersja nie powiedzie się, jeśli input nie zawiera prawidłowej reprezentacji ciągu daty i godziny lub nie zawiera daty i godziny w oczekiwanym formacie zdefiniowanym przez formatslub jeśli formats jest null. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli parametr input został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną wartość DateTimeStyles.

-lub-

NoCurrentDateDefault nie jest obsługiwana.

-lub-

styles obejmuje wzajemnie wykluczające się wartości DateTimeStyles.

Przykłady

W poniższym przykładzie zdefiniowano wiele formatów wejściowych dla ciągu reprezentującego wartość daty i godziny i przesunięcia, a następnie przekazuje ciąg wprowadzony przez użytkownika do metody 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

Uwagi

Metoda TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analizuje ciąg reprezentujący datę zgodną z dowolnym wzorcem przypisanym do tablicy formats. Jeśli ciąg input nie pasuje do żadnego z tych wzorców z żadnymi odmianami zdefiniowanymi przez parametr styles, operacja analizowania zakończy się niepowodzeniem, a metoda zwróci false. Oprócz porównywania input z wieloma ciągami, które zawierają specyfikatory formatu, to przeciążenie działa identycznie z metodą DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).

Parametr formats to tablica ciągów, której elementy zawierają jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego definiujący możliwy wzorzec input. Aby uzyskać szczegółowe informacje na temat prawidłowych kodów formatowania, zobacz standardowe ciągi formatu daty i godziny oraz niestandardowe ciągi formatu daty i godziny. Jeśli dopasowany element w formats zawiera z, zzlub zzz specyfikatorów formatu niestandardowego, aby wskazać, że przesunięcie musi znajdować się w input, to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizy zakończy się niepowodzeniem, a metoda zwróci false.

Ważny

Użycie parametru formats tego przeciążenia w celu określenia wielu formatów może pomóc zmniejszyć frustrację wielu użytkowników podczas wprowadzania dat i godzin. W szczególności możliwość definiowania wielu wzorców wejściowych umożliwia aplikacji obsługę reprezentacji daty i godziny, które mogą zawierać lub brak zer wiodących w miesiącach, dniach, godzinach, minutach i sekundach. W tym przykładzie przedstawiono ilustrację.

Jeśli dopasowany element w formats wymaga, aby input zawierał datę, ale nie godzinę, wynikowy obiekt DateTimeOffset jest przypisany o godzinie północy (0:00:00). Jeśli pasujący element w formats wymaga, aby dane wejściowe zawierały godzinę, ale nie datę, wynikowy obiekt DateTimeOffset ma przypisaną bieżącą datę w systemie lokalnym. Jeśli pasujący element w formats nie wymaga, aby input zawierał przesunięcie, przesunięcie wynikowego obiektu DateTimeOffset zależy od wartości parametru styles. Jeśli styles zawiera AssumeLocal, przesunięcie lokalnej strefy czasowej zostanie przypisane do obiektu DateTimeOffset. Jeśli styles zawiera AssumeUniversal, przesunięcie uniwersalnego czasu koordynowanego (UTC) lub +00:00 zostanie przypisane do obiektu DateTimeOffset. Jeśli żadna z wartości nie zostanie określona, zostanie użyte przesunięcie lokalnej strefy czasowej.

Określone symbole i ciągi daty i godziny używane w input są definiowane przez parametr formatProvider. To samo dotyczy dokładnego wzorca input, jeśli pasujący element formats jest standardowym ciągiem specyfikatora formatu. Parametr formatProvider może mieć jedną z następujących wartości:

Obiekt CultureInfo reprezentujący kulturę, na podstawie której input jest interpretowany. Obiekt DateTimeFormatInfo zwrócony przez właściwość CultureInfo.DateTimeFormat definiuje symbole i formatowanie w input.
Obiekt DateTimeFormatInfo, który definiuje format danych daty i godziny.

Jeśli formatprovider jest null, używany jest obiekt CultureInfo odpowiadający bieżącej kulturze.

Parametr styles określa, czy biały znak jest dozwolony w ciągu wejściowym, wskazuje, w jaki sposób ciągi bez jawnego składnika przesunięcia są analizowane i obsługuje konwersję UTC w ramach operacji analizowania. Wszystkie elementy członkowskie wyliczenia DateTimeStyles są obsługiwane z wyjątkiem NoCurrentDateDefault. W poniższej tabeli wymieniono efekt każdego obsługiwanego elementu członkowskiego.

członek `DateTimeStyles`	Zachowanie
AdjustToUniversal	Analizuje `input` i w razie potrzeby konwertuje go na czas UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania metody DateTimeOffset.ToUniversalTime zwróconego obiektu DateTimeOffset.
AssumeLocal	Jeśli dopasowany element w `formats` nie wymaga, aby `input` zawierał wartość przesunięcia, zwracany obiekt DateTimeOffset otrzymuje przesunięcie lokalnej strefy czasowej. Jest to wartość domyślna.
AssumeUniversal	Jeśli dopasowany element w `formats` nie wymaga, aby `input` zawierać wartość przesunięcia, zwrócony obiekt DateTimeOffset otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączanie wewnętrznego odstępu nieokreślonego przez elementy w `formats`. Dodatkowe białe znaki mogą występować między składnikami daty i godziny oraz w poszczególnych składnikach (z wyjątkiem przesunięcia) i są ignorowane podczas analizowania ciągu.
AllowLeadingWhite	Umożliwia `input` dołączanie spacji wiodących, które nie są określone przez elementy w `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych nieokreślonych przez elementy w `formats`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` dołączanie spacji wiodących, końcowych i wewnętrznych nieokreślonych przez elementy w `formats`. Podczas analizowania ciągu są ignorowane wszystkie dodatkowe znaki odstępu, które nie zostały określone w dopasowanym elemecie w `formats`.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w określonym elemenie w `formats` w celu pomyślnego dopasowania. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ struktura DateTimeOffset nie zawiera właściwości `Kind`.

Uwagi dotyczące wywoływania

W programie .NET Framework 4 TryParseExact zwraca false, jeśli ciąg, który ma zostać przeanalizowany, zawiera składnik godziny i projektant AM/PM, które nie są zgodne. W programie .NET Framework 3.5 i starszych wersjach projektant am/PM jest ignorowany.

Dotyczy

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

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Konwertuje reprezentację daty i godziny w zakresie znaków na jego DateTimeOffset odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji daty i godziny musi być dokładnie zgodny z określonym formatem.

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

Parametry

input: ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące datę i godzinę konwersji.

format: ReadOnlySpan<Char>

Specyfikator formatu, który definiuje wymagany format input.

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat input.

styles: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format input. Typową wartością do określenia jest None.

result: DateTimeOffset

Gdy metoda zwróci wartość , zawiera DateTimeOffset równoważną dacie i godzinie input, jeśli konwersja zakończyła się pomyślnie lub dateTimeOffset.MinValue, jeśli konwersja nie powiodła się. Konwersja kończy się niepowodzeniem, jeśli

Zwraca

Boolean

true, jeśli parametr input został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną wartość DateTimeStyles. -or- NoCurrentDateDefault nie jest obsługiwany. -or- styles zawiera wzajemnie wykluczające się wartości DateTimeStyles.

Uwagi

To przeciążenie jest podobne do metody DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), z tą różnicą, że ta metoda nie zgłasza wyjątku, jeśli konwersja nie powiedzie się. Analizuje reprezentację daty i godziny, która musi być dokładnie zgodna ze wzorcem określonym przez format parametru. Jeśli input nie pasuje do tego wzorca, z pewnymi możliwymi odmianami białych znaków zdefiniowanych przez parametr styles operacja analizowania kończy się niepowodzeniem, a metoda zwraca false.

Parametr format to zakres znaków, który zawiera jeden standardowy specyfikator formatu lub co najmniej jeden specyfikator formatu niestandardowego definiujący wymagany wzorzec input. Aby uzyskać szczegółowe informacje na temat prawidłowych kodów formatowania, zobacz standardowe ciągi formatu daty i godziny oraz niestandardowe ciągi formatu daty i godziny. Jeśli format zawiera z, zzlub zzz specyfikatory formatu niestandardowego, aby wskazać, że przesunięcie musi znajdować się w input, to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizowania zakończy się niepowodzeniem, a metoda zwróci false.

Jeśli format wymaga, aby input zawierała datę, ale nie godzinę, wynikowy obiekt DateTimeOffset ma przypisaną godzinę północy (0:00:00). Jeśli format wymaga, aby input zawierał godzinę, ale nie datę, wynikowy obiekt DateTimeOffset ma przypisaną bieżącą datę w systemie lokalnym. Jeśli format nie wymaga, aby input zawierał przesunięcie, przesunięcie wynikowego obiektu DateTimeOffset zależy od wartości parametru styles. Jeśli styles zawiera AssumeLocal, przesunięcie lokalnej strefy czasowej zostanie przypisane do obiektu DateTimeOffset. Jeśli styles zawiera AssumeUniversal, przesunięcie uniwersalnego czasu koordynowanego (UTC) lub +00:00 zostanie przypisane do obiektu DateTimeOffset. Jeśli żadna z wartości nie zostanie określona, zostanie użyte przesunięcie lokalnej strefy czasowej.

Określone symbole i ciągi daty i godziny używane w input są definiowane przez parametr formatProvider. To samo dotyczy dokładnego wzorca input, jeśli format jest standardowym ciągiem specyfikatora formatu. Parametr formatProvider może mieć jedną z następujących wartości:

Obiekt CultureInfo reprezentujący kulturę, na podstawie której input jest interpretowany. Obiekt DateTimeFormatInfo zwrócony przez właściwość CultureInfo.DateTimeFormat definiuje symbole i standardowe formaty dozwolone w input.
Obiekt DateTimeFormatInfo, który definiuje format danych daty i godziny.

Jeśli formatprovider jest null, używany jest obiekt CultureInfo odpowiadający bieżącej kulturze.

członek `DateTimeStyles`	Zachowanie
AdjustToUniversal	Analizuje `input` i w razie potrzeby konwertuje go na czas UTC. Jest to równoważne analizowaniu reprezentacji daty i godziny, a następnie wywoływanie metody DateTimeOffset.ToUniversalTime zwróconego obiektu DateTimeOffset.
AssumeLocal	Jeśli `format` nie wymaga, aby `input` zawierał wartość przesunięcia, zwracany obiekt DateTimeOffset otrzymuje przesunięcie lokalnej strefy czasowej. Jest to zachowanie domyślne.
AssumeUniversal	Jeśli `format` nie wymaga, aby `input` zawierał wartość przesunięcia, zwrócony obiekt DateTimeOffset otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączanie wewnętrznego odstępu nieokreślonego przez format. Dodatkowe białe znaki mogą występować między składnikami daty i godziny oraz w ramach poszczególnych składników, innych niż przesunięcie, i jest ignorowane podczas analizowania ciągu.
AllowLeadingWhite	Umożliwia `input` dołączanie spacji wiodących, które nie są określone przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych nieokreślonych przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` dołączanie spacji wiodących, końcowych i wewnętrznych nieokreślonych przez `format`. Wszystkie dodatkowe znaki odstępu nieokreślone w `format` są ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w `format`. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ struktura DateTimeOffset nie zawiera właściwości `Kind`.

Dotyczy

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

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Konwertuje reprezentację daty i godziny w zakresie znaków na jego DateTimeOffset odpowiednik przy użyciu określonych formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji daty i godziny musi być dokładnie zgodny z jednym z określonych formatów.

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

Parametry

input: ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące datę i godzinę konwersji.

formats: String[]

Tablica ciągów formatu standardowego lub niestandardowego, które definiują dopuszczalne formaty input.

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat input.

styles: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format input. Typową wartością do określenia jest None.

result: DateTimeOffset

Zwraca

Boolean

true, jeśli parametr input został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną wartość DateTimeStyles. -or- NoCurrentDateDefault nie jest obsługiwany. -or- styles zawiera wzajemnie wykluczające się wartości DateTimeStyles.

Uwagi

Ta metoda analizuje reprezentację ciągu daty zgodnej z dowolnym wzorcem przypisanym do tablicy formats. Jeśli input nie pasuje do żadnego z tych wzorców z żadnymi odmianami zdefiniowanymi przez parametr styles, operacja analizowania zakończy się niepowodzeniem, a metoda zwróci false. Oprócz porównywania input z wieloma ciągami, które zawierają specyfikatory formatu, to przeciążenie działa identycznie z metodą DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).

Ważny

Jeśli dopasowany element w formats wymaga, aby input zawierał datę, ale nie godzinę, wynikowy obiekt DateTimeOffset jest przypisany o godzinie północy (0:00:00). Jeśli pasujący element w formats wymaga, aby dane wejściowe zawierały godzinę, ale nie datę, wynikowy obiekt DateTimeOffset ma przypisaną bieżącą datę w systemie lokalnym. Jeśli pasujący element w formats nie wymaga, aby input zawierał przesunięcie, przesunięcie wynikowego obiektu DateTimeOffset zależy od wartości parametru styles. Jeśli styles zawiera DateTimeStyles.AssumeLocal, przesunięcie lokalnej strefy czasowej zostanie przypisane do obiektu DateTimeOffset. Jeśli styles zawiera DateTimeStyles.AssumeUniversal, przesunięcie uniwersalnego czasu koordynowanego (UTC) lub +00:00 zostanie przypisane do obiektu DateTimeOffset. Jeśli żadna z wartości nie zostanie określona, zostanie użyte przesunięcie lokalnej strefy czasowej.

Określone symbole daty i godziny używane w input są definiowane przez parametr formatProvider. To samo dotyczy dokładnego wzorca input, jeśli pasujący element formats jest standardowym ciągiem specyfikatora formatu. Parametr formatProvider może mieć jedną z następujących wartości:

Obiekt CultureInfo reprezentujący kulturę, na podstawie której input jest interpretowany. Obiekt DateTimeFormatInfo zwrócony przez właściwość CultureInfo.DateTimeFormat definiuje symbole i formatowanie w input.
Obiekt DateTimeFormatInfo, który definiuje format danych daty i godziny.

Jeśli formatprovider jest null, używany jest obiekt CultureInfo odpowiadający bieżącej kulturze.

członek `DateTimeStyles`	Zachowanie
AdjustToUniversal	Analizuje `input` i w razie potrzeby konwertuje go na czas UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania metody DateTimeOffset.ToUniversalTime zwróconego obiektu DateTimeOffset.
AssumeLocal	Jeśli dopasowany element w `formats` nie wymaga, aby `input` zawierał wartość przesunięcia, zwracany obiekt DateTimeOffset otrzymuje przesunięcie lokalnej strefy czasowej. Jest to wartość domyślna.
AssumeUniversal	Jeśli dopasowany element w `formats` nie wymaga, aby `input` zawierać wartość przesunięcia, zwrócony obiekt DateTimeOffset otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączanie wewnętrznego odstępu nieokreślonego przez elementy w `formats`. Dodatkowe białe znaki mogą występować między składnikami daty i godziny oraz w poszczególnych składnikach (z wyjątkiem przesunięcia) i są ignorowane podczas analizowania ciągu.
AllowLeadingWhite	Umożliwia `input` dołączanie spacji wiodących, które nie są określone przez elementy w `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych nieokreślonych przez elementy w `formats`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` dołączanie spacji wiodących, końcowych i wewnętrznych nieokreślonych przez elementy w `formats`. Podczas analizowania ciągu są ignorowane wszystkie dodatkowe znaki odstępu, które nie zostały określone w dopasowanym elemecie w `formats`.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w określonym elemenie w `formats` w celu pomyślnego dopasowania. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ struktura DateTimeOffset nie zawiera właściwości `Kind`.

Dotyczy

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

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Źródło:: DateTimeOffset.cs

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTimeOffset przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być dokładnie zgodny z określonym formatem.

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

Parametry

input: String

Ciąg zawierający datę i godzinę do przekonwertowania.

format: String

Specyfikator formatu, który definiuje wymagany format input.

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat input.

styles: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format danych wejściowych. Typową wartością do określenia jest None.

result: DateTimeOffset

Gdy metoda zwraca wartość , zawiera DateTimeOffset równoważną dacie i godzinie input, jeśli konwersja zakończyła się pomyślnie lub DateTimeOffset.MinValue, jeśli konwersja nie powiodła się. Konwersja kończy się niepowodzeniem, jeśli parametr input jest nulllub nie zawiera prawidłowej reprezentacji ciągu daty i godziny w oczekiwanym formacie zdefiniowanym przez format i provider. Ten parametr jest przekazywany niezainicjowany.

Zwraca

Boolean

true, jeśli parametr input został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną wartość DateTimeStyles.

-lub-

NoCurrentDateDefault nie jest obsługiwana.

-lub-

styles obejmuje wzajemnie wykluczające się wartości DateTimeStyles.

Przykłady

W poniższym przykładzie użyto metody TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) ze specyfikatorami formatu standardowego i niestandardowego, niezmienną kulturą i różnymi wartościami DateTimeStyles, aby przeanalizować kilka ciągów daty i godziny.

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.

W poniższym przykładzie użyto różnych wartości DateTimeStyles, aby przeanalizować tablicę ciągów, które mają być zgodne z ISO 8601. Jak pokazano w danych wyjściowych z przykładu, ciągi, które są w odpowiednim formacie, nie mogą być analizowane, jeśli:

zawierają białe znaki i odpowiednią flagę DateTimeStyles (na przykład DateTimeStyles.AllowWhiteSpaces nie została podana w wywołaniu metody.
zawierają elementy daty i godziny, które są poza zakresem.

Ciągi, które nie określają przesunięcia UTC, zakłada się, że przesunięcie lokalnej strefy czasowej (w tym przypadku -07:00, co odzwierciedla przesunięcie strefy czasowej Pacyfik (czas letni), chyba że flaga DateTimeStyles.AssumeUniversal jest podana w wywołaniu metody. W takim przypadku zakłada się, że są one uniwersalnym czasem koordynowanym.

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

Uwagi

To przeciążenie metody TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) przypomina metodę DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), z tą różnicą, że ta metoda nie zgłasza wyjątku w przypadku niepowodzenia konwersji. Analizuje on reprezentację ciągu daty i godziny, która musi dokładnie odpowiadać wzorzec określony przez parametr format. Jeśli ciąg input nie jest zgodny z tym wzorcem, z pewnymi możliwymi odmianami białych znaków zdefiniowanych przez parametr styles operacja analizowania kończy się niepowodzeniem, a metoda zwraca false.

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego definiujący wymagany wzorzec input. Aby uzyskać szczegółowe informacje na temat prawidłowych kodów formatowania, zobacz standardowe ciągi formatu daty i godziny oraz niestandardowe ciągi formatu daty i godziny. Jeśli format zawiera z, zzlub zzz specyfikatory formatu niestandardowego, aby wskazać, że przesunięcie musi znajdować się w input, to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizowania zakończy się niepowodzeniem, a metoda zwróci false.

Obiekt CultureInfo reprezentujący kulturę, na podstawie której input jest interpretowany. Obiekt DateTimeFormatInfo zwrócony przez właściwość CultureInfo.DateTimeFormat definiuje symbole i standardowe formaty dozwolone w input.
Obiekt DateTimeFormatInfo, który definiuje format danych daty i godziny.

Jeśli formatprovider jest null, używany jest obiekt CultureInfo odpowiadający bieżącej kulturze.

członek `DateTimeStyles`	Zachowanie
AdjustToUniversal	Analizuje `input` i w razie potrzeby konwertuje go na czas UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania metody DateTimeOffset.ToUniversalTime zwróconego obiektu DateTimeOffset.
AssumeLocal	Jeśli `format` nie wymaga, aby `input` zawierał wartość przesunięcia, zwracany obiekt DateTimeOffset otrzymuje przesunięcie lokalnej strefy czasowej. Jest to zachowanie domyślne.
AssumeUniversal	Jeśli `format` nie wymaga, aby `input` zawierał wartość przesunięcia, zwrócony obiekt DateTimeOffset otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączanie wewnętrznego odstępu nieokreślonego przez format. Dodatkowe białe znaki mogą występować między składnikami daty i godziny oraz w ramach poszczególnych składników, innych niż przesunięcie, i jest ignorowane podczas analizowania ciągu.
AllowLeadingWhite	Umożliwia `input` dołączanie spacji wiodących, które nie są określone przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych nieokreślonych przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` dołączanie spacji wiodących, końcowych i wewnętrznych nieokreślonych przez `format`. Wszystkie dodatkowe znaki odstępu nieokreślone w `format` są ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w `format`. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ struktura DateTimeOffset nie zawiera właściwości `Kind`.

Uwagi dotyczące wywoływania

Zobacz też

ParseExact

Dotyczy

Udostępnij za pośrednictwem

DateTimeOffset.TryParseExact Metoda

Definicja

Przeciążenia

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

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Dotyczy

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

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

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

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

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

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

Dodatkowe zasoby