DateTime.Parse Metoda

Definicja

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime .

Przeciążenia

Parse(String)

Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu konwencji bieżącej kultury.

Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres pamięci, który zawiera reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

Parse(String, IFormatProvider, DateTimeStyles)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

Przykłady

Wiele przykładów wywołujących metodę DateTime.Parse jest przeplatane w sekcji Uwagi w tym artykule i w dokumentacji poszczególnych DateTime.Parse przeciążeń.

Uwaga

Niektóre przykłady w języku C# w tym artykule są uruchamiane w Try.NET uruchamiać kod i zabaw. Wybierz przycisk Uruchom, aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu możesz go zmodyfikować i uruchomić zmodyfikowany kod, ponownie wybierając pozycję Uruchom. Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub, jeśli kompilacja zakończy się niepowodzeniem, w oknie interaktywnym zostaną wyświetlone wszystkie komunikaty o błędach kompilatora języka C#.

Lokalna strefa czasowa wbudowanego Try.NET i zabaw dla kodu jest Uniwersalny czas koordynowany, czyli UTC. Może to mieć wpływ na zachowanie i dane wyjściowe przykładów ilustrujących typy DateTime , i oraz ich elementy DateTimeOffset TimeZoneInfo członkowskie.

Możesz również pobrać kompletny zestaw przykładów DateTime.Parse , które znajdują się w projekcie platformy .NET Core dla języka C#.

Uwagi

W tej sekcji:

Jaką metodę wywołać?

Działanie Call
Przeanalizuj ciąg daty i godziny przy użyciu konwencji bieżącej kultury. Parse(String) Przeciążenie
Przeanalizuj ciąg daty i godziny przy użyciu konwencji określonej kultury. Parse(String, IFormatProvider) przeciążenie (zobacz Konwencje analizowania i kultury)
Przeanalizuj ciąg daty i godziny z specjalnymi elementami stylu (takimi jak białe znaki lub brak odstępu). Parse(String, IFormatProvider, DateTimeStyles) Przeciążenie
Przeanalizuj ciąg daty i godziny, który musi być w określonym formacie. DateTime.ParseExact lub DateTime.TryParseExact
Przeanalizuj ciąg daty i godziny i przeprowadź konwersję na czas UTC lub lokalny. Parse(String, IFormatProvider, DateTimeStyles) Przeciążenie
Przeanalizuj ciąg daty i godziny bez obsługi wyjątków. Metoda DateTime.TryParse
Przywracanie (zaokrąglanie) wartości daty i godziny utworzonej przez operację formatowania. Przekaż ciąg formatu standardowego "o" lub "r" do ToString(String) metody i wywołaj Parse(String, IFormatProvider, DateTimeStyles) przeciążenie za pomocą polecenia DateTimeStyles.RoundtripKind
Przeanalizuj ciąg daty i godziny w stałym formacie na granicach maszyny (i prawdopodobnie kulturowej). DateTime.ParseExact lub DateTime.TryParseExact metoda

Ciąg do analizy

Metoda Parse próbuje przekonwertować reprezentację ciągu wartości daty i godziny na równoważną DateTime . Próbuje całkowicie przeanalizować ciąg wejściowy bez zgłaszania wyjątku FormatException .

Ważne

Jeśli operacja analizowania nie powiedzie się z powodu nierozpoznanego formatu ciągu, Parse metoda zgłasza FormatExceptionwartość , natomiast TryParse metoda zwraca falsewartość . Ponieważ obsługa wyjątków może być kosztowna, należy użyć Parse , gdy operacja analizowania zakończy się pomyślnie, ponieważ źródło danych wejściowych jest zaufane. TryParse zaleca się, gdy błędy analizowania są prawdopodobne, szczególnie dlatego, że źródło wejściowe nie jest zaufane lub masz rozsądne wartości domyślne, aby zastąpić ciągi, które nie są pomyślnie analizowane.

Ciąg, który ma zostać przeanalizowany, może przyjmować dowolne z następujących formularzy:

  • Ciąg ze składnikiem daty i godziny.

  • Ciąg z datą, ale bez składnika godziny. Jeśli składnik czasu jest nieobecny, metoda zakłada 12:00 północy. Jeśli składnik daty ma dwucyfrowy rok, jest konwertowany na rok na Calendar.TwoDigitYearMax podstawie bieżącego kalendarza kultury bieżącej lub bieżącego kalendarza określonej kultury (jeśli używasz przeciążenia z argumentem bez wartości null provider ).

  • Ciąg ze składnikiem daty zawierającym tylko miesiąc i rok, ale bez składnika dnia. Metoda zakłada pierwszy dzień miesiąca.

  • Ciąg ze składnikiem daty zawierającym tylko miesiąc i dzień, ale bez składnika roku. Metoda zakłada bieżący rok.

  • Ciąg z godziną, ale bez składnika daty. Metoda zakłada bieżącą datę, chyba że wywołasz Parse(String, IFormatProvider, DateTimeStyles) przeciążenie i uwzględnisz DateTimeStyles.NoCurrentDateDefault w styles argumencie , w którym przypadku metoda zakłada datę 1 stycznia 0001 roku.

  • Ciąg ze składnikiem czasu zawierającym tylko godzinę i projektator AM/PM bez składnika daty. Metoda zakłada bieżącą datę i godzinę bez minut i bez sekund. To zachowanie można zmienić, wywołując przeciążenie i dołączając DateTimeStyles.NoCurrentDateDefault do argumentu Parse(String, IFormatProvider, DateTimeStyles) styles, w którym metoda zakłada datę 1 stycznia 0001 r.

  • Ciąg zawierający informacje o strefie czasowej i zgodny z normą ISO 8601. W poniższych przykładach pierwszy ciąg wyznacza uniwersalny czas koordynowany (UTC), a drugi wyznacza czas w strefie czasowej, która wynosi siedem godzin wcześniej niż UTC:

    "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.000000-07:00"

  • Ciąg, który zawiera projektator GMT i jest zgodny z formatem czasu RFC 1123; na przykład:

    "Sob, 01 Listopad 2008 19:35:00 GMT"

  • Ciąg, który zawiera informacje o dacie i godzinie wraz z informacjami o przesunięciach strefy czasowej; na przykład:

    "03/01/2009 05:42:00 -5:00"

Poniższy przykład analizuje ciągi w każdym z tych formatów przy użyciu konwencji formatowania bieżącej kultury, co w tym przypadku jest kulturą en-US:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM
module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Jeśli ciąg wejściowy reprezentuje dzień przestępny w roku przestępnym w kalendarzu używanym przez metodę analizowania (zobacz Konwencje analizowania i kultury), Parse metoda analizuje ciąg pomyślnie. Jeśli ciąg wejściowy reprezentuje dzień przestępny w roku bez przestępnego, metoda zgłasza wartość FormatException.

Parse Ponieważ metoda próbuje przeanalizować reprezentację ciągu daty i godziny przy użyciu reguł formatowania bieżącej lub określonej kultury, próba przeanalizowania ciągu w różnych kulturach może zakończyć się niepowodzeniem. Aby przeanalizować określony format daty i godziny w różnych ustawieniach regionalnych, użyj jednego z przeciążeń DateTime.ParseExact metody i podaj specyfikator formatu.

Konwencje analizy i kultury

Wszystkie przeciążenia Parse metody są wrażliwe na kulturę, chyba że ciąg, który ma zostać przeanalizowany (reprezentowany w s poniższej tabeli) jest zgodny ze wzorcem ISO 8601. Operacja analizowania używa informacji o formatowaniu w obiekcie pochodnym DateTimeFormatInfo w następujący sposób:

Ważne

Ery w kalendarzach japońskich są oparte na suchem rzeszy i w związku z tym oczekuje się, że zmienią się. Na przykład 1 maja 2019 r. oznaczał początek ery Reiwa w i JapaneseCalendar JapaneseLunisolarCalendar . Taka zmiana ery ma wpływ na wszystkie aplikacje, które używają tych kalendarzy. Aby uzyskać więcej informacji i określić, czy dotyczy to aplikacji, zobacz Obsługa nowej ery w kalendarzu japońskim na platformie .NET. Aby uzyskać informacje na temat testowania aplikacji w Windows w celu zapewnienia ich gotowości na zmianę ery, zobacz Przygotowanie aplikacji na zmianę ery japońskiej. Aby uzyskać informacje o funkcjach na platformie .NET, które obsługują kalendarze z wieloma erami, oraz o najlepszych rozwiązaniach podczas pracy z kalendarzami, które obsługują wiele er, zobacz Praca z erami.

Jeśli dzwonisz I provider jest Informacje o formatowaniu pochodzą z
Parse(String) - Bieżąca kultura (DateTimeFormatInfo.CurrentInfo właściwość)
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) obiekt DateTimeFormatInfo Określony DateTimeFormatInfo obiekt
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) null Bieżąca kultura (DateTimeFormatInfo.CurrentInfo właściwość)
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) obiekt CultureInfo Właściwość CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) Implementacja niestandardowa IFormatProvider Metoda IFormatProvider.GetFormat

Gdy informacje o formatowaniu pochodzą z DateTimeFormatInfo obiektu, DateTimeFormatInfo.Calendar właściwość definiuje kalendarz używany w operacji analizowania.

Jeśli analizujesz ciąg daty i godziny przy użyciu DateTimeFormatInfo obiektu z dostosowanymi ustawieniami, które różnią się od standardowej kultury, użyj ParseExact metody zamiast Parse metody , aby zwiększyć szanse na pomyślną konwersję. Niestandardowy ciąg daty i godziny może być skomplikowany i trudny do przeanalizowana. Metoda Parse próbuje przeanalizować ciąg z kilkoma niejawnymi wzorcami analizy, z których wszystkie mogą zakończyć się niepowodzeniem. ParseExact Natomiast metoda wymaga jawnego wyznaczenia jednego lub większej liczby dokładnych wzorców analizy, które prawdopodobnie powiedzą się. Aby uzyskać więcej informacji, zobacz sekcję "DateTimeFormatInfo and Dynamic Data" w temacie DateTimeFormatInfo .

Ważne

Należy pamiętać, że konwencje formatowania dla określonej kultury są dynamiczne i mogą ulec zmianie. Oznacza to, że operacje analizowania, które zależą od konwencji formatowania domyślnej (bieżącej) kultury lub które określają IFormatProvider obiekt reprezentujący kulturę inną niż niezmienna kultura może nieoczekiwanie zakończyć się niepowodzeniem, jeśli wystąpi którykolwiek z następujących:

  • Dane specyficzne dla kultury zmieniły się między wersjami głównymi lub pomocniczymi .NET Framework lub w wyniku aktualizacji do istniejącej wersji .NET Framework.
  • Dane specyficzne dla kultury odzwierciedlają preferencje użytkownika, które mogą różnić się od komputera do maszyny lub sesji do sesji.
  • Dane specyficzne dla kultury reprezentują kulturę zastępczą, która zastępuje ustawienia kultury standardowej lub kultury niestandardowej.

Aby zapobiec trudnościom podczas analizowania danych i ciągów czasowych skojarzonych ze zmianami w danych kulturowych, można przeanalizować ciągi daty i godziny przy użyciu niezmiennej kultury lub wywołać ParseExact metodę lub TryParseExact i określić dokładny format ciągu do przeanalizowania. W przypadku serializacji i deserializacji danych daty i godziny można użyć konwencji formatowania niezmiennej kultury lub serializacji i deserializacji DateTime wartości w formacie binarnym.

Aby uzyskać więcej informacji, zobacz sekcję "Dane kultury dynamicznej" w CultureInfo temacie i sekcję "Utrwalanie wartości daty/godziny" w DateTime temacie.

Analizowanie i elementy stylu

Wszystkie Parse przeciążenia ignorują znaki wiodące, wewnętrzne lub końcowe w ciągu wejściowym (reprezentowane w s poniższej tabeli). Data i godzina mogą być w nawiasach kwadratowych z kilkoma wiodącymi i końcowymi znakami ZNAKU NUMERU ("#", U+0023) i mogą być wyjęci z co najmniej jednym znakiem NULL (U+0000).

Ponadto Parse(String, IFormatProvider, DateTimeStyles) przeciążenie ma styles parametr składający się z co najmniej jednego elementu członkowskiego wyliczenia DateTimeStyles . Ten parametr definiuje, jak s należy interpretować i jak operacja analizy powinna zostać przekonwertowana s na datę i godzinę. W poniższej tabeli opisano wpływ każdego DateTimeStyles elementu członkowskiego na operację analizowania.

Element członkowski DateTimeStyles Wpływ na konwersję
AdjustToUniversal Analizuje i, w razie potrzeby, konwertuje s go na UTC w następujący sposób:

- Jeśli s zawiera przesunięcie strefy czasowej lub jeśli s nie zawiera informacji o strefie czasowej, ale styles zawiera AssumeLocal flagę, metoda analizuje ciąg, wywołuje ToUniversalTime konwersję zwróconej DateTime wartości na UTC i ustawia Kind właściwość na DateTimeKind.Utc.
- Jeśli s wskazuje, że reprezentuje czas UTC lub jeśli s nie zawiera informacji o strefie czasowej, ale styles zawiera flagę AssumeUniversal , metoda analizuje ciąg, nie wykonuje konwersji strefy czasowej na zwracaną DateTime wartość i ustawia Kind właściwość na DateTimeKind.Utc.
- We wszystkich innych przypadkach flaga nie ma wpływu.
AllowInnerWhite Ta wartość jest ignorowana. Wewnętrzne odstępy są zawsze dozwolone w elementach daty i godziny elementu s.
AllowLeadingWhite Ta wartość jest ignorowana. Wiodące białe znaki są zawsze dozwolone w elementach daty i godziny elementu s.
AllowTrailingWhite Ta wartość jest ignorowana. Końcowe białe znaki są zawsze dozwolone w elementach daty i godziny elementu s.
AllowWhiteSpaces Określa, że s może zawierać wiodące, wewnętrzne i końcowe białe spacje. Jest to zachowanie domyślne. Nie można go zastąpić, podając bardziej restrykcyjną DateTimeStyles wartość wyliczenia, taką jak None.
AssumeLocal Określa, że jeśli s nie ma żadnych informacji o strefie czasowej, zakłada się czas lokalny. Jeśli flaga AdjustToUniversal nie jest obecna, Kind właściwość zwróconej DateTime wartości jest ustawiona na DateTimeKind.Localwartość .
AssumeUniversal Określa, że jeśli s nie ma żadnych informacji o strefie czasowej, zakłada się, że utc. O ile flaga AdjustToUniversal nie jest obecna, metoda konwertuje zwróconą DateTime wartość z czasu UTC na czas lokalny i ustawia jej Kind właściwość na DateTimeKind.Local.
None Choć ważna, wartość ta jest ignorowana.
RoundtripKind W przypadku ciągów zawierających informacje o strefie czasowej próbuje zapobiec konwersji ciągu daty i godziny na wartość reprezentującą czas lokalny z właściwością Kind ustawioną DateTime na DateTimeKind.Local. Zazwyczaj taki ciąg jest tworzony przez wywołanie DateTime.ToString(String) metody i przy użyciu specyfikatora formatu standardowego "o", "r" lub "u".

Wartość zwracana i DateTime.Kind

Przeciążenia DateTime.Parse zwracają DateTime wartość, której Kind właściwość zawiera informacje o strefie czasowej. Może to wskazywać, że czas wynosi:

Ogólnie rzecz biorąc, Parse metoda zwraca DateTime obiekt, którego Kind właściwość to DateTimeKind.Unspecified. Parse Jednak metoda może również wykonać konwersję strefy czasowej i ustawić wartość Kind właściwości inaczej, w zależności od wartości parametrów s istyles:

Jeśli użytkownik Konwersja strefy czasowej Właściwość Kind
s zawiera informacje o strefie czasowej. Data i godzina są konwertowane na godzinę w lokalnej strefie czasowej. DateTimeKind.Local
s zawiera informacje o strefie czasowej i styles zawiera flagę AdjustToUniversal . Data i godzina są konwertowane na uniwersalny czas koordynowany (UTC). DateTimeKind.Utc
s zawiera projekt strefy czasowej Z lub GMT i styles zawiera flagę RoundtripKind . Data i godzina są interpretowane jako UTC. DateTimeKind.Utc

Poniższy przykład konwertuje ciągi daty, które zawierają informacje o strefie czasowej w lokalnej strefie czasowej:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Można również zachować wartość właściwości daty i godziny Kind podczas operacji formatowania i analizowania przy użyciu flagi DateTimeStyles.RoundtripKind . W poniższym przykładzie pokazano, jak flaga RoundtripKind wpływa na operację DateTime analizowania wartości, które są konwertowane na ciągi przy użyciu specyfikatora formatu "o", "r" lub "u".

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu konwencji bieżącej kultury.

public:
 static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime

Parametry

s
String

Ciąg zawierający datę i godzinę, które należy przekształcić. Aby uzyskać więcej informacji, zobacz Ciąg do analizy .

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w elemencie s.

Wyjątki

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

Przykłady

Poniższy przykład analizuje reprezentację ciągu kilku wartości daty i godziny według:

  • Przy użyciu domyślnego dostawcy formatu, który udostępnia konwencje formatowania bieżącej kultury komputera używanego do tworzenia przykładowych danych wyjściowych. Dane wyjściowe z tego przykładu odzwierciedlają konwencje formatowania kultury en-US.

  • Używając domyślnej wartości stylu, czyli AllowWhiteSpaces.

FormatException Obsługuje wyjątek, który jest zgłaszany, gdy metoda próbuje przeanalizować reprezentację ciągu daty i godziny przy użyciu innych konwencji formatowania kultury. Pokazuje również, jak pomyślnie przeanalizować wartość daty i godziny, która nie używa konwencji formatowania bieżącej kultury.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Uwagi

Jeśli s zawiera informacje o strefie czasowej, ta metoda zwraca DateTime wartość, której Kind właściwość jest DateTimeKind.Local i konwertuje datę i godzinę na s czas lokalny. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca DateTime wartość, której Kind właściwość to DateTimeKind.Unspecified.

To przeciążenie próbuje przeanalizować s przy użyciu konwencji formatowania bieżącej kultury. Bieżąca kultura jest wskazywana przez CurrentCulture właściwość . Aby przeanalizować ciąg przy użyciu konwencji formatowania określonej kultury, wywołaj Parse(String, IFormatProvider) przeciążenia lub Parse(String, IFormatProvider, DateTimeStyles) .

To przeciążenie próbuje przeanalizować s przy użyciu DateTimeStyles.AllowWhiteSpaces stylu.

Zobacz też

Dotyczy

Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public static DateTime Parse (string s, IFormatProvider provider);
public static DateTime Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Parametry

s
String

Ciąg zawierający datę i godzinę, które należy przekształcić. Aby uzyskać więcej informacji, zobacz Ciąg do analizy .

provider
IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury.s Zobacz Analizowanie i konwencje kulturowe

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w s określonym przez provider.

Implementuje

Wyjątki

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

Przykłady

Poniższy przykład analizuje tablicę ciągów dat przy użyciu konwencji kultur en-US, fr-FR i de-DE. Pokazuje, że reprezentacje ciągu pojedynczej daty można interpretować inaczej w różnych kulturach.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Uwagi

Jeśli s zawiera informacje o strefie czasowej, ta metoda zwraca DateTime wartość, której Kind właściwość jest DateTimeKind.Local i konwertuje datę i godzinę na s czas lokalny. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca DateTime wartość, której Kind właściwość to DateTimeKind.Unspecified.

To przeciążenie próbuje przeanalizować s przy użyciu DateTimeStyles.AllowWhiteSpaces stylu.

Zobacz też

Dotyczy

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres pamięci, który zawiera reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametry

s
ReadOnlySpan<Char>

Zakres pamięci, który zawiera ciąg do przeanalizowana. Aby uzyskać więcej informacji, zobacz Ciąg do analizy .

provider
IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury.s Zobacz Analizowanie i konwencje kulturowe

styles
DateTimeStyles

Bitowa kombinacja wartości wyliczenia, która wskazuje elementy stylu, które mogą być obecne w s operacji analizy, aby operacja analizy zakończyła się powodzeniem, i która definiuje sposób interpretowania analizowanej daty w odniesieniu do bieżącej strefy czasowej lub bieżącej daty. Typową wartością do określenia jest None.

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w elemencie s, zgodnie z instrukcjami provider i styles.

Wyjątki

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

styles zawiera nieprawidłową kombinację DateTimeStyles wartości. Na przykład zarówno , jak AssumeLocal i AssumeUniversal.

Dotyczy

Parse(String, IFormatProvider, DateTimeStyles)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parametry

s
String

Ciąg zawierający datę i godzinę, które należy przekształcić. Aby uzyskać więcej informacji, zobacz Ciąg do analizy .

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.s Zobacz Analizowanie i konwencje kulturowe

styles
DateTimeStyles

Bitowa kombinacja wartości wyliczenia, która wskazuje elementy stylu, które mogą być obecne w s operacji analizy, aby operacja analizy zakończyła się powodzeniem, i która definiuje sposób interpretowania analizowanej daty w odniesieniu do bieżącej strefy czasowej lub bieżącej daty. Typową wartością do określenia jest None.

Zwraca

DateTime

Obiekt, który jest odpowiednikiem daty i godziny zawartej w elemencie s, zgodnie z instrukcjami provider i styles.

Wyjątki

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

styles zawiera nieprawidłową kombinację DateTimeStyles wartości. Na przykład zarówno , jak AssumeLocal i AssumeUniversal.

Przykłady

Poniższy przykład przedstawia metodę Parse(String, IFormatProvider, DateTimeStyles) i wyświetla wartość Kind właściwości wynikowych DateTime wartości.

using System;
using System.Globalization;

public class ParseDateExample
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture ;
      DateTimeStyles styles;
      DateTime result;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);
      }

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
Imports System.Globalization

Module ParseDateExample
   Public Sub Main()
      Dim dateString As String  
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim result As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      Try
         result = DateTime.Parse(dateString, culture, styles)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, result, result.Kind.ToString())
      Catch e As FormatException
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End Try      
   End Sub
End Module
'
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Uwagi

Ta metoda przeładuje datę i godzinę w s obiekcie i ustawia Kind właściwość zwracanej DateTime wartości w następujący sposób:

Jeśli użytkownik Konwersja strefy czasowej Właściwość Kind
s nie zawiera informacji o strefie czasowej. Brak. DateTimeKind.Unspecified
s zawiera informacje o strefie czasowej. Do godziny w lokalnej strefie czasowej DateTimeKind.Local
s zawiera informacje o strefie czasowej i styles zawiera flagę DateTimeStyles.AdjustToUniversal . Do koordynowanego uniwersalnego czasu (UTC) DateTimeKind.Utc
s zawiera designator strefy czasowej Z lub GMT i styles zawiera DateTimeStyles.RoundtripKindelement . Brak. DateTimeKind.Utc

Zobacz też

Dotyczy