DateTimeOffset.ParseExact 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

ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTimeOffset przy użyciu określonych 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.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Konwertuje określoną reprezentację ciągu daty i godziny na jej DateTimeOffset odpowiednik 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.
ParseExact(String, String, IFormatProvider)	Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTimeOffset przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Konwertuje zakres znaków reprezentujący datę i godzinę odpowiednika DateTimeOffset 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.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Konwertuje zakres znaków, który zawiera reprezentację ciągu daty i godziny 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.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTimeOffset przy użyciu określonych 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 DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametry

input: String

Ciąg zawierający datę i godzinę, które należy przekształcić.

formats: String[]

Tablica specyfikatorów formatu definiujących 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 .input

Zwraca

DateTimeOffset

Obiekt, który jest odpowiednikiem daty i godziny zawartej w parametrze input , zgodnie z parametrami formats, formatProvideri styles .

Wyjątki

ArgumentException

Przesunięcie jest większe niż 14 godzin lub mniejsze niż-14 godzin.

-lub-

styles zawiera nieobsługiwaną wartość.

-lub-

Parametr styles zawiera DateTimeStyles wartości, których nie można używać razem.

ArgumentNullException

input to null.

FormatException

input jest pustym ciągiem ("").

-lub-

input nie zawiera prawidłowej reprezentacji ciągu daty i godziny.

-lub-

Żaden element nie zawiera prawidłowego formats specyfikatora formatu.

-lub-

Składnik godziny i projektator AM/PM w elemencie input nie zgadzają się.

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) analizuje reprezentację ciągu daty zgodnej z dowolnym wzorcem przypisanym do parametru formats . input Jeśli ciąg nie pasuje do żadnego z tych wzorców z żadnymi odmianami zdefiniowanymi przez styles parametr, metoda zgłasza wartość FormatException. Oprócz porównywania z input wieloma wzorcami formatowania 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 co najmniej jeden specyfikator formatu niestandardowego definiujący możliwy wzorzec parametru input . Po wywołaniu input metody musi być zgodna z jednym z tych wzorców. 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, metoda zgłasza błąd FormatException.

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 zawierał godzinę, input 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 formatu input, jeśli pasujący element formats elementu jest ciągiem specyfikatora formatu standardowego. 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 `format`. Dodatkowe białe znaki mogą pojawiać się między składnikami daty i godziny a poszczególnymi składnikami (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 `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` dołączanie spacji końcowych, które nie są określone przez `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 `formats`element . 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 `formats` , aby wystąpiło dopasowanie. 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 metoda zgłasza FormatException wartość , jeśli ciąg do ParseExact 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.

Zobacz też

Dotyczy

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Konwertuje określoną reprezentację ciągu daty i godziny na jej DateTimeOffset odpowiednik 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 DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parametry

input: String

Ciąg zawierający datę i godzinę, które należy przekształcić.

format: String

Specyfikator formatu, który definiuje oczekiwany 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

Zwraca

DateTimeOffset

Obiekt, który jest odpowiednikiem daty i godziny zawartej w parametrze input , zgodnie z parametrami format, formatProvideri styles .

Wyjątki

ArgumentException

Przesunięcie jest większe niż 14 godzin lub mniejsze niż-14 godzin.

-lub-

Parametr styles zawiera nieobsługiwaną wartość.

-lub-

Parametr styles zawiera DateTimeStyles wartości, których nie można używać razem.

ArgumentNullException

input to null.

-lub-

format to null.

FormatException

input jest pustym ciągiem ("").

-lub-

input nie zawiera prawidłowej reprezentacji ciągu daty i godziny.

-lub-

format jest pustym ciągiem.

-lub-

Składnik godziny i konfirator AM/PM w elemencie input nie zgadzają się.

Przykłady

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

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AssumeUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
}

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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 mogą być analizowane, jeśli:

zawierają białe znaki i odpowiednią DateTimeStyles flagę (na przykład DateTimeStyles.AllowWhiteSpaces nie podano jej 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), chyba że DateTimeStyles.AssumeUniversal flaga zostanie podana w wywołaniu metody. W takim przypadku zakłada się, że są one uniwersalnym czasem koordynowanym.

module parseexact_iso8601_2

open System
open System.Globalization

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" |] 

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        try
            let date = DateTimeOffset.ParseExact(dateString, "O", null, styles)
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        with :? FormatException ->
            printfn $"   FormatException: Unable to convert '{dateString}'"

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Uwagi

Metoda DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) analizuje reprezentację ciągu daty, która musi być w formacie zdefiniowanym format przez parametr . Wymaga to również, aby <Date>elementy , <Time>i <Offset> ciągu reprezentacja daty i godziny pojawiały się w kolejności określonej przez format. input Jeśli ciąg nie jest zgodny ze wzorcem parametruformat, z żadnymi odmianami zdefiniowanymi przez styles parametr , metoda zgłasza wyjątek FormatException. DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) Natomiast metoda analizuje reprezentację ciągu daty w dowolnym formacie rozpoznawanym przez obiekt dostawcy DateTimeFormatInfo formatu. Parse umożliwia <Date>również wyświetlenie elementów , <Time>i <Offset> ciągu reprezentujących datę i godzinę w dowolnej kolejności.

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego definiujący wymagany wzorzec parametru 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 specyfikatory formatu niestandardowego z, zzlub zzz , aby wskazać, że przesunięcie musi być obecne w inputelemecie , to przesunięcie musi zawierać znak ujemny lub znak dodatni. Jeśli brakuje znaku, metoda zgłasza wyjątek FormatException.

Jeśli format wymaga, aby input zawierał datę, ale nie godzinę, wynikowy DateTimeOffset obiekt ma przypisaną godzinę 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 przesunięcia input , przesunięcie wynikowego DateTimeOffset obiektu zależy od wartości parametru styles . Jeśli styles parametr zawiera AssumeLocal, przesunięcie lokalnej strefy czasowej jest przypisywane do DateTimeOffset obiektu . Jeśli styles uwzględnia AssumeUniversalwartość , do obiektu jest przypisywane DateTimeOffset przesunięcie uniwersalnego czasu koordynowanego (UTC) lub +00:00. 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 input parametrze formatProvider są definiowane przez parametr . To samo dotyczy dokładnego inputformatu , jeśli format jest ciągiem specyfikatora formatu standardowego. Parametr formatProvider może być jednym z następujących:

CultureInfo Obiekt reprezentujący kulturę, na podstawie której input jest interpretowana. Obiekt DateTimeFormatInfo zwracany 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 parametr ma nullwartość , CultureInfo używany jest obiekt odpowiadający bieżącej kulturze.

Parametr styles określa, czy biały znak 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 są obsługiwane z DateTimeStyles wyjątkiem NoCurrentDateDefault. Poniższa tabela zawiera listę działania każdego z obsługiwanych elementów członkowskich.

`DateTimeStyles` Członkowskich	Zachowanie
AdjustToUniversal	`input` Analizuje i w razie potrzeby konwertuje go na czas UTC. Jest to odpowiednik analizowania ciągu, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli `format` nie wymaga, aby `input` zawierała wartość przesunięcia, zwracany DateTimeOffset obiekt otrzymuje przesunięcie lokalnej strefy czasowej. Jest to wartość domyślna.
AssumeUniversal	Jeśli `format` nie wymaga, aby `input` zawierał wartość 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 `format`parametr . Dodatkowe białe znaki mogą pojawiać się między składnikami daty i godziny oraz w poszczególnych składnikach i są 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` uwzględnianie spacji końcowych, które nie są określone przez `format`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnianie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez `format`. Wszystkie dodatkowe znaki odstępu, które nie zostały określone w pliku `format` , są ignorowane podczas analizowania ciągu.
None	Wskazuje, że dodatkowe białe znaki nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w pliku `format`. 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 metoda zgłasza FormatException wyjątek ParseExact , jeśli ciąg do przeanalizowania zawiera składnik godziny i projektowania AM/PM, które nie są zgodne. W .NET Framework 3.5 i starszych wersjach projektowania AM/PM jest ignorowany.

Zobacz też

Dotyczy

ParseExact(String, String, IFormatProvider)

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTimeOffset przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider formatProvider);

public static DateTimeOffset ParseExact (string input, string format, IFormatProvider? formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parametry

input: String

Ciąg zawierający datę i godzinę, które należy przekształcić.

format: String

Specyfikator formatu definiujący oczekiwany format input.

formatProvider: IFormatProvider

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

Zwraca

DateTimeOffset

Obiekt, który jest odpowiednikiem daty i godziny zawartej w input określonym przez format element i formatProvider.

Wyjątki

ArgumentException

Przesunięcie jest większe niż 14 godzin lub mniejsze niż-14 godzin.

ArgumentNullException

input to null.

-lub-

format to null.

FormatException

input jest pustym ciągiem ("").

-lub-

input nie zawiera prawidłowej reprezentacji ciągu daty i godziny.

-lub-

format jest pustym ciągiem.

-lub-

Składnik godziny i projektator AM/PM w elemencie input nie zgadzają się.

Przykłady

W poniższym przykładzie użyto DateTimeOffset.ParseExact(String, String, IFormatProvider) metody z specyfikatorami formatu standardowego i niestandardowego oraz niezmienną kulturą do analizowania kilku ciągów daty i godziny.

string dateString, format;
DateTimeOffset result;
CultureInfo provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

Poniższy przykład analizuje tablicę ciągów, które mają być zgodne z normą ISO 8601. Jak pokazuje dane wyjściowe z przykładu, ciągi z spacjami wiodącymi lub końcowymi nie mogą pomyślnie przeanalizować ciągów z elementami daty i godziny, które są poza zakresem.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

Metoda ParseExact(String, String, IFormatProvider) analizuje reprezentację ciągu daty, która musi być w formacie zdefiniowanym format przez parametr . Wymaga również, aby <Date>elementy , <Time>i <Offset> ciągu reprezentacja daty i godziny pojawiały się w kolejności określonej przez format. Jeśli ciąg nie jest zgodny z input tym format parametrem, metoda zgłasza wartość FormatException. DateTimeOffset.Parse(String, IFormatProvider) Natomiast metoda analizuje reprezentację ciągu daty w dowolnym formacie rozpoznawanym przez obiekt dostawcy DateTimeFormatInfo formatu. Parse Umożliwia <Date>również wyświetlenie elementów , <Time>i <Offset> ciągu reprezentacji daty i godziny w dowolnej kolejności.

Parametr format jest ciągiem zawierającym jeden specyfikator formatu standardowego lub co najmniej jeden specyfikator formatu niestandardowego, który definiuje wymagany format parametru 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 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, metoda zgłasza błąd FormatException.

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, wynikowy DateTimeOffset obiekt jest przypisany do przesunięcia strefy czasowej systemu lokalnego.

Określone symbole i ciągi daty i godziny używane w input parametrze formatProvider są definiowane przez parametr, podobnie jak dokładny format input , 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 jego 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.

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres znaków reprezentujący datę i godzinę odpowiednika DateTimeOffset 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametry

input: ReadOnlySpan<Char>

Zakres znaków reprezentujący datę i godzinę.

format: ReadOnlySpan<Char>

Zakres znaków, który zawiera specyfikator formatu, który definiuje oczekiwany format input.

formatProvider: IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury dotyczące inputelementu .

styles: DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca dozwolony format .input

Zwraca

DateTimeOffset

Obiekt, który jest odpowiednikiem daty i godziny zawartej w parametrze input , zgodnie z parametrami format, formatProvideri styles .

Wyjątki

ArgumentException

Przesunięcie jest większe niż 14 godzin lub mniejsze niż-14 godzin. -or — styles parametr zawiera nieobsługiwaną wartość. -or — styles parametr zawiera DateTimeStyles wartości, których nie można używać razem.

FormatException

input jest pustym zakresem znaków. -or- input nie zawiera prawidłowej reprezentacji ciągu daty i godziny. -or — format jest pustym zakresem znaków. -or — składnik godziny i projektator AM/PM w programie input nie zgadzają się.

Uwagi

Ta metoda analizuje zakres znaków reprezentujący datę, która musi być w formacie zdefiniowanym format przez parametr . Wymaga również, aby <Date>elementy , <Time>i <Offset> ciągu reprezentacja daty i godziny pojawiały się w kolejności określonej przez format. Jeśli input wzorzec nie jest zgodny format , metoda zgłasza błąd FormatException. DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Natomiast metoda analizuje reprezentację ciągu daty w dowolnym formacie rozpoznawanym przez obiekt dostawcy DateTimeFormatInfo formatu. Parse Umożliwia <Date>również wyświetlenie elementów , <Time>i <Offset> ciągu reprezentacji daty i godziny w dowolnej kolejności.

Parametr format jest zakresem znaków, który zawiera specyfikator formatu standardowego jednego znaku lub co najmniej jeden specyfikator formatu niestandardowego, który definiuje wymagany format parametru 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 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, metoda zgłasza błąd FormatException.

Określone symbole i ciągi daty i godziny używane w input parametrze formatProvider są definiowane przez parametr, podobnie jak dokładny format input , jeśli format jest specyfikatorem formatu standardowego. 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 jego 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.

Dotyczy

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

Konwertuje zakres znaków, który zawiera reprezentację ciągu daty i godziny 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 DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

public static DateTimeOffset ParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parametry

input: ReadOnlySpan<Char>

Zakres znaków zawierający datę i godzinę konwersji.

formats: String[]

Tablica specyfikatorów formatu definiujących 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 .input

Zwraca

DateTimeOffset

Obiekt, który jest odpowiednikiem daty i godziny zawartej w parametrze input , zgodnie z parametrami formats, formatProvideri styles .

Wyjątki

ArgumentException

Przesunięcie jest większe niż 14 godzin lub mniejsze niż-14 godzin. — zawiera styles nieobsługiwaną wartość. -or - Parametr styles zawiera DateTimeStyles wartości, których nie można używać razem.

FormatException

input jest pustym zakresem znaków. -or- input nie zawiera prawidłowej reprezentacji ciągu daty i godziny. -or- Żaden element elementu formats nie zawiera prawidłowego specyfikatora formatu. -or- Składnik godziny i konfirator AM/PM w input elemencie nie zgadzają się.

Uwagi

Ta metoda analizuje zakres znaków reprezentujący datę zgodną z dowolną z wzorców przypisanych do parametru formats . Jeśli input żaden z tych wzorców nie jest zgodny z żadnymi odmianami zdefiniowanymi przez styles parametr, metoda zgłasza wartość FormatException. Oprócz porównywania z input wieloma wzorcami formatowania to przeciążenie działa identycznie z DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) metodą .

Ważne

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	`input` Analizuje i w razie potrzeby konwertuje go na czas UTC. Jest to odpowiednik analizowania ciągu, a następnie wywoływania DateTimeOffset.ToUniversalTime metody zwracanego DateTimeOffset obiektu.
AssumeLocal	Jeśli dopasowany element w `formats` pliku 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 dopasowany element w `formats` pliku nie wymaga, aby `input` zawierał wartość 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 `format`parametr . Dodatkowe białe znaki mogą występować między składnikami daty i godziny oraz w ramach poszczególnych składników (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 `formats`. Są one ignorowane podczas analizowania ciągu.
AllowTrailingWhite	Umożliwia `input` uwzględnianie spacji końcowych, które nie są określone przez `formats`. Są one ignorowane podczas analizowania ciągu.
AllowWhiteSpaces	Umożliwia `input` uwzględnianie spacji wiodących, końcowych i wewnętrznych, które nie są określone przez `formats`. Podczas analizowania ciągu wszystkie dodatkowe znaki odstępu nieokreślone w dopasowanym elemecie są `formats` ignorowane.
None	Wskazuje, że dodatkowe białe znaki nie są dozwolone w pliku `input`. Białe znaki muszą być wyświetlane dokładnie tak, jak określono w określonym elemecie `formats` , aby wystąpiło dopasowanie. Jest to zachowanie domyślne.
RoundtripKind	Nie ma wpływu, ponieważ DateTimeOffset struktura nie zawiera `Kind` właściwości.

Dotyczy

Udostępnij za pośrednictwem

DateTimeOffset.ParseExact Metoda

Definicja

Przeciążenia

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

ParseExact(String, String, IFormatProvider)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Uwagi dotyczące wywoływania

Zobacz też

Dotyczy

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

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

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

Dodatkowe zasoby