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 odpowiednik DateTimeOffset . Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)	Konwertuje reprezentację daty i godziny w zakresie znaków na 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 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 odpowiednik DateTimeOffset przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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 ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych 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ę, które należy przekształcić.

formats: String[]

Tablica, która definiuje oczekiwane formaty .input

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.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 zostanie zwrócona, zawiera DateTimeOffset odpowiednik daty i godziny 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 input ciąg nie zawiera prawidłowej reprezentacji ciągu daty i godziny lub nie zawiera daty i godziny w oczekiwanym formacie zdefiniowanym przez format, lub jeśli formats jest to null. Ten parametr jest przekazywany jako niezainicjowany.

Zwraca

Boolean

trueinput jeśli parametr został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną DateTimeStyles wartość.

-lub-

NoCurrentDateDefault nie jest obsługiwane.

-lub-

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

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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) metody .

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 reprezentację ciągu daty zgodnej z dowolnym wzorcem przypisanym do tablicy formats . input Jeśli ciąg nie pasuje do żadnego z tych wzorców z żadnymi odmianami zdefiniowanymi przez styles parametr, operacja analizowania kończy się niepowodzeniem, a metoda zwraca falsewartość . Oprócz porównywania input z wieloma ciągami, które zawierają specyfikatory formatu, to przeciążenie działa identycznie z DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodą .

Parametr formats jest tablicą ciągów, której elementy zawierają jeden specyfikator formatu standardowego lub jeden lub więcej specyfikatorów formatu niestandardowego input, które definiują możliwy wzorzec . 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 pliku formats zawiera zspecyfikatory formatu , zzlub zzz niestandardowego, aby wskazać, że przesunięcie musi znajdować się w inputelemecie , to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizy zakończy się niepowodzeniem, a metoda zwróci falsewartość .

Ważne

formats Użycie parametru 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 wiodących zer w miesiącach, dniach, godzinach, minutach i sekundach. W tym przykładzie przedstawiono ilustrację.

Jeśli dopasowany element w pliku formats wymaga, aby zawierał datę, input ale nie godzinę, wynikowy DateTimeOffset obiekt jest przypisany o godzinie północy (0:00:00). Jeśli dopasowany element w pliku formats wymaga, aby dane wejściowe zawierały godzinę, ale nie datę, wynikowy DateTimeOffset obiekt jest przypisany do bieżącej daty w systemie lokalnym. Jeśli dopasowany element w elemecie formats nie wymaga input przesunięcia, przesunięcie wynikowego DateTimeOffset obiektu zależy od wartości parametru styles . Jeśli styles zawiera AssumeLocalelement , przesunięcie lokalnej strefy czasowej jest przypisywane do DateTimeOffset obiektu. Jeśli styles obejmuje AssumeUniversalprzesunięcie czasu uniwersalnego koordynowanego (UTC) lub +00:00, zostanie przypisane do DateTimeOffset obiektu. Jeśli żadna wartość nie jest określona, używane jest przesunięcie lokalnej strefy czasowej.

Określone symbole i ciągi daty i godziny używane w programie input są definiowane przez formatProvider parametr . To samo dotyczy dokładnego wzorca input , jeśli pasujący element formats elementu to standardowy ciąg specyfikatora formatu. Parametr formatProvider może być jednym z następujących:

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

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

Parametr styles określa, czy biały odstęp jest dozwolony w ciągu wejściowym, wskazuje, jak 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. Poniższa tabela zawiera listę działania każdego z obsługiwanych elementów członkowskich.

`DateTimeStyles` Członkowskich	Zachowanie
AdjustToUniversal	Analizuje i, w razie potrzeby, konwertuje `input` go na UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli dopasowany element w elemecie `formats` nie wymaga, aby `input` zawierał wartość przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie lokalnej strefy czasowej. Jest to wartość domyślna.
AssumeUniversal	Jeśli pasujący element w pliku `formats` nie wymaga `input` wartości przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączenie wewnętrznego odstępu nieokreślonego przez elementy w elemecie `formats`. Dodatkowe białe znaki mogą pojawiać się 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` uwzględnianie spacji wiodących, które nie są określone przez elementy w elemecie `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych, które nie są określone przez elementy w elemecie `formats`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnienie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez elementy w elemecie `formats`. Wszystkie dodatkowe znaki odstępu nieokreślone w dopasowanym elemecie są `formats` ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w określonym elemecie w `formats` celu pomyślnego dopasowania. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ DateTimeOffset struktura nie zawiera `Kind` właściwości.

Uwagi dotyczące wywoływania

W .NET Framework 4 zwraca wartość TryParseExactfalse , jeśli ciąg do przeanalizowania zawiera składnik godziny i projektator AM/PM, które nie są zgodne. W .NET Framework wersji 3.5 i starszych projektator 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 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.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

trueinput jeśli parametr został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

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

Uwagi

To przeciążenie jest podobne do DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metody, z tą różnicą, że ta metoda nie zgłasza wyjątku w przypadku niepowodzenia konwersji. Analizuje reprezentację daty i godziny, która musi być dokładnie zgodna ze wzorcem format określonym przez parametr . Jeśli input ten wzorzec nie jest zgodny z pewnymi możliwymi odmianami odstępu zdefiniowanego styles przez parametr, operacja analizowania kończy się niepowodzeniem, a metoda zwraca falsewartość .

Parametr format jest zakresem znaków, który zawiera jeden standardowy specyfikator formatu lub co najmniej jeden specyfikator formatu niestandardowego input, który definiuje wymagany wzorzec . 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 zspecyfikatory formatu , zzlub zzz niestandardowego, aby wskazać, że przesunięcie musi być obecne w inputelemecie , to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizowania kończy się niepowodzeniem, a metoda zwraca falsewartość .

Jeśli format wymaga, aby input zawierał datę, ale nie godzinę, wynikowy DateTimeOffset obiekt jest przypisany o godzinie północy (0:00:00). Jeśli format wymaga, aby input zawierał godzinę, ale nie datę, wynikowy DateTimeOffset obiekt jest przypisany do bieżącej daty w systemie lokalnym. Jeśli format nie wymaga input przesunięcia, przesunięcie wynikowego DateTimeOffset obiektu zależy od wartości parametru styles . Jeśli styles zawiera AssumeLocalelement , przesunięcie lokalnej strefy czasowej jest przypisywane do DateTimeOffset obiektu. Jeśli styles obejmuje AssumeUniversalprzesunięcie czasu uniwersalnego koordynowanego (UTC) lub +00:00, zostanie przypisane do DateTimeOffset obiektu. Jeśli żadna wartość nie jest określona, używane jest przesunięcie lokalnej strefy czasowej.

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

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

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

Parametr styles określa, czy odstęp jest dozwolony w ciągu wejściowym, wskazuje, jak 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. Poniższa tabela zawiera listę działania każdego z obsługiwanych elementów członkowskich.

`DateTimeStyles` Członkowskich	Zachowanie
AdjustToUniversal	Analizuje i, w razie potrzeby, konwertuje `input` go na UTC. Jest ona równoważna analizowaniu reprezentacji daty i godziny, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli `format` nie wymaga wartości `input` przesunięcia, zwracany DateTimeOffset obiekt otrzymuje przesunięcie lokalnej strefy czasowej. Jest to zachowanie domyślne.
AssumeUniversal	Jeśli `format` nie wymaga wartości `input` przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączenie wewnętrznego odstępu nieokreślonego według formatu. Dodatkowe białe odstępy mogą pojawiać się 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` uwzględnianie 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, które nie są określone przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnienie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez `format`element . Wszystkie dodatkowe znaki odstępu nieokreślone w pliku `format` są ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w `format`pliku . Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ DateTimeOffset struktura nie zawiera `Kind` właściwości.

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 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 standardowych lub niestandardowych ciągów formatu definiujących dopuszczalne formaty .input

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.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

trueinput jeśli parametr został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

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

Uwagi

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

Ważne

Jeśli dopasowany element w pliku formats wymaga, aby zawierał datę, input ale nie godzinę, wynikowy DateTimeOffset obiekt jest przypisany o godzinie północy (0:00:00). Jeśli dopasowany element w pliku formats wymaga, aby dane wejściowe zawierały godzinę, ale nie datę, wynikowy DateTimeOffset obiekt jest przypisany do bieżącej daty w systemie lokalnym. Jeśli dopasowany element w elemecie formats nie wymaga input przesunięcia, przesunięcie wynikowego DateTimeOffset obiektu zależy od wartości parametru styles . Jeśli styles zawiera DateTimeStyles.AssumeLocalelement , przesunięcie lokalnej strefy czasowej jest przypisywane do DateTimeOffset obiektu. Jeśli styles obejmuje DateTimeStyles.AssumeUniversalprzesunięcie czasu uniwersalnego koordynowanego (UTC) lub +00:00, zostanie przypisane do DateTimeOffset obiektu. Jeśli żadna wartość nie jest określona, używane jest przesunięcie lokalnej strefy czasowej.

Określone symbole daty i godziny używane w pliku input są definiowane przez formatProvider parametr . To samo dotyczy dokładnego wzorca input , jeśli pasujący element formats elementu to standardowy ciąg specyfikatora formatu. Parametr formatProvider może być jednym z następujących:

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

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

`DateTimeStyles` Członkowskich	Zachowanie
AdjustToUniversal	Analizuje i, w razie potrzeby, konwertuje `input` go na UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli dopasowany element w elemecie `formats` nie wymaga, aby `input` zawierał wartość przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie lokalnej strefy czasowej. Jest to wartość domyślna.
AssumeUniversal	Jeśli pasujący element w pliku `formats` nie wymaga `input` wartości przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączenie wewnętrznego odstępu nieokreślonego przez elementy w elemecie `formats`. Dodatkowe białe znaki mogą pojawiać się 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` uwzględnianie spacji wiodących, które nie są określone przez elementy w elemecie `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych, które nie są określone przez elementy w elemecie `formats`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnienie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez elementy w elemecie `formats`. Wszystkie dodatkowe znaki odstępu nieokreślone w dopasowanym elemecie są `formats` ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w określonym elemecie w `formats` celu pomyślnego dopasowania. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ DateTimeOffset struktura nie zawiera `Kind` właściwości.

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 odpowiednik DateTimeOffset przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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ę, które należy przekształcić.

format: String

Specyfikator formatu, który definiuje wymagany format input.

formatProvider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.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 zostanie zwrócona, zawiera DateTimeOffset odpowiednik daty i godziny 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 input parametr ma nullwartość , lub nie zawiera prawidłowej reprezentacji ciągu daty i godziny w oczekiwanym formacie zdefiniowanym przez format i provider. Ten parametr jest przekazywany jako niezainicjowany.

Zwraca

Boolean

trueinput jeśli parametr został pomyślnie przekonwertowany; w przeciwnym razie false.

Wyjątki

ArgumentException

styles zawiera niezdefiniowaną DateTimeStyles wartość.

-lub-

NoCurrentDateDefault nie jest obsługiwane.

-lub-

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

Przykłady

W poniższym przykładzie użyto TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metody ze standardowymi i niestandardowymi specyfikatorami formatu, niezmienną kulturą i różnymi DateTimeStyles wartościami do analizowania kilku 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 DateTimeStyles wartości, aby przeanalizować tablicę ciągów, które mają być zgodne z normą ISO 8601. Jak pokazuje dane wyjściowe z przykładu, ciągi, które są w odpowiednim formacie, nie można przeanalizować, jeśli:

zawierają białe znaki i odpowiednią DateTimeStyles flagę (taką jak DateTimeStyles.AllowWhiteSpaces nie została dostarczona 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ę przesunięcie lokalnej strefy czasowej (w tym przypadku -07:00, co odzwierciedla przesunięcie strefy czasowej Pacyfik (czas letni), chyba że DateTimeStyles.AssumeUniversal flaga jest dostarczana 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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) metody jest podobne do DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) metody, z tą różnicą, że ta metoda nie zgłasza wyjątku, jeśli konwersja nie powiedzie się. Analizuje ona reprezentację ciągu daty i godziny, która musi być dokładnie zgodna ze wzorcem format określonym przez parametr . Jeśli ciąg nie pasuje do input tego wzorca, z pewnymi możliwymi odmianami odstępu zdefiniowanego styles przez parametr, operacja analizowania kończy się niepowodzeniem, a metoda zwraca falsewartość .

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego input, który definiuje wymagany wzorzec . 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 zspecyfikatory formatu , zzlub zzz niestandardowego, aby wskazać, że przesunięcie musi być obecne w inputelemecie , to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, operacja analizowania kończy się niepowodzeniem, a metoda zwraca falsewartość .

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

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

`DateTimeStyles` Członkowskich	Zachowanie
AdjustToUniversal	Analizuje i, w razie potrzeby, konwertuje `input` go na UTC. Jest on odpowiednikiem analizowania ciągu, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli `format` nie wymaga wartości `input` przesunięcia, zwracany DateTimeOffset obiekt otrzymuje przesunięcie lokalnej strefy czasowej. Jest to zachowanie domyślne.
AssumeUniversal	Jeśli `format` nie wymaga wartości `input` przesunięcia, zwrócony DateTimeOffset obiekt otrzymuje przesunięcie UTC (+00:00).
AllowInnerWhite	Umożliwia `input` dołączenie wewnętrznego odstępu nieokreślonego według formatu. Dodatkowe białe odstępy mogą pojawiać się 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` uwzględnianie 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, które nie są określone przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnienie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez `format`element . Wszystkie dodatkowe znaki odstępu nieokreślone w pliku `format` są ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe odstępy nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w `format`pliku . Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ DateTimeOffset struktura nie zawiera `Kind` właściwości.

Uwagi dotyczące wywoływania

Zobacz też

ParseExact

Dotyczy

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

Opinia

Dodatkowe zasoby