DateTime.Parse Metoda
Definicja
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 reprezentację ciągu daty i godziny na równoważną DateTime.
Przeciążenia
| Parse(String) |
Konwertuje ciąg reprezentujący datę i godzinę na jego DateTime odpowiednik przy użyciu konwencji bieżącej kultury. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analizuje zakres znaków w wartości. |
| Parse(String, IFormatProvider) |
Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu informacji o formacie specyficznym dla kultury. |
| Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Konwertuje zakres pamięci, który zawiera ciąg reprezentujący datę i godzinę na jego DateTime odpowiednik przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania. |
| Parse(String, IFormatProvider, DateTimeStyles) |
Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania. |
Przykłady
Wiele przykładów, które wywołają metodę DateTime.Parse, są przeplatane w uwagi sekcji tego artykułu i w dokumentacji poszczególnych przeciążeń DateTime.Parse.
Nuta
Niektóre przykłady języka C# w tym artykule są uruchamiane w Try.NET wbudowanym modułu uruchamiającego kod i plac zabaw. Wybierz pozycję Uruchom, aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu można go zmodyfikować i uruchomić zmodyfikowany kod, wybierając ponownie 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 modułu uruchamiającego kod Try.NET i plac zabaw to uniwersalny czas koordynowany lub UTC. Może to mieć wpływ na zachowanie i dane wyjściowe przykładów ilustrujących typy DateTime, DateTimeOffseti TimeZoneInfo oraz ich składowe.
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:
- Którą metodę wywołać?
- ciąg do analizowania
- parsing i konwencje kulturowe
- analizowanie i elementy stylu
- wartość zwracana i DateTime.Kind
Która metoda jest wywoływana?
| Do | Nazwać |
|---|---|
| Przeanalizuj ciąg daty i godziny przy użyciu konwencji bieżącej kultury. | przeciążenie Parse(String) |
| Przeanalizuj ciąg daty i godziny przy użyciu konwencji określonej kultury. | przeciążenie Parse(String, IFormatProvider) (zobacz Parsing and Cultural Conventions) |
| Przeanalizuj ciąg daty i godziny ze specjalnymi elementami stylu (takimi jak biały znak lub brak odstępu). | przeciążenie Parse(String, IFormatProvider, DateTimeStyles) |
| 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. | przeciążenie Parse(String, IFormatProvider, DateTimeStyles) |
| Przeanalizuj ciąg daty i godziny bez obsługi wyjątków. | DateTime.TryParse, metoda |
| Przywracanie (round-trip) wartości daty i godziny utworzonej przez operację formatowania. | Przekaż ciąg formatu standardowego "o" lub "r" do metody ToString(String) i wywołaj przeciążenie Parse(String, IFormatProvider, DateTimeStyles) przy użyciu DateTimeStyles.RoundtripKind |
| Przeanalizuj ciąg daty i godziny w stałym formacie między granicami maszyny (i ewentualnie kulturowymi). | metoda DateTime.ParseExact lub DateTime.TryParseExact |
Ciąg do przeanalizowana
Metoda Parse próbuje przekonwertować ciąg reprezentujący wartość daty i godziny na równoważną DateTime. Próbuje całkowicie przeanalizować ciąg wejściowy bez zgłaszania wyjątku FormatException.
Ważny
Jeśli operacja analizowania nie powiedzie się z powodu nierozpoznanego formatu ciągu, metoda Parse zgłasza FormatException, podczas gdy metoda TryParse zwraca false. Ponieważ obsługa wyjątków może być kosztowna, należy użyć Parse, gdy operacja analizowania zakończy się powodzeniem, ponieważ źródło danych wejściowych jest zaufane. TryParse jest preferowana, gdy prawdopodobnie występują błędy analizowania, szczególnie dlatego, że źródło danych wejściowych nie jest zaufane lub istnieje uzasadnione wartości domyślne do zastąpienia ciągów, które nie są analizowane pomyślnie.
Ciąg, który ma zostać przeanalizowany, może przyjmować dowolną z następujących form:
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 podstawie Calendar.TwoDigitYearMax bieżącego kalendarza kultury lub bieżącego kalendarza określonej kultury (jeśli używasz przeciążenia z argumentem
providerinnej niż null).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 przeciążenie Parse(String, IFormatProvider, DateTimeStyles) i dołączysz DateTimeStyles.NoCurrentDateDefault w argumencie
styles, w którym metoda przyjmuje datę 1 stycznia 0001 r.Ciąg ze składnikiem godziny, który zawiera 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 Parse(String, IFormatProvider, DateTimeStyles) i dołączając DateTimeStyles.NoCurrentDateDefault w argumencie
styles. W takim przypadku metoda przyjmuje 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 jest siedem godzin wcześniej niż UTC:
"2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-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 zawierający 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), metoda Parse analizuje ciąg pomyślnie. Jeśli ciąg wejściowy reprezentuje dzień przestępny w roku nieprzestąpnym, metoda zgłasza FormatException.
Ponieważ metoda Parse próbuje przeanalizować reprezentację ciągu daty i godziny przy użyciu reguł formatowania bieżącej lub określonej kultury, próba przeanalizowana 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ń metody DateTime.ParseExact i podaj specyfikator formatu.
Analizowanie i konwencje kulturowe
Wszystkie przeciążenia metody Parse są wrażliwe na kulturę, chyba że ciąg, który ma zostać przeanalizowany (reprezentowany przez s w poniższej tabeli) jest zgodny ze wzorcem ISO 8601. Operacja analizowania używa informacji formatowania w obiekcie DateTimeFormatInfo, który jest pochodny w następujący sposób:
Ważny
Era w japońskich kalendarzach opiera się na panowaniu cesarza i dlatego oczekuje się, że się zmieni. Na przykład 1 maja 2019 r. oznaczało początek ery Reiwa w JapaneseCalendar i JapaneseLunisolarCalendar. Taka zmiana ery wpływa na wszystkie aplikacje korzystające z tych kalendarzy. Aby uzyskać więcej informacji i określić, czy twoje aplikacje mają wpływ, zobacz Obsługa nowej ery w kalendarzu japońskim na platformie .NET. Aby uzyskać informacje na temat testowania aplikacji w systemach Windows w celu zapewnienia gotowości do zmiany ery, zobacz Prepare your application for the Japanese era change. Aby uzyskać informacje o funkcjach na platformie .NET, które obsługują kalendarze z wieloma epokami i aby uzyskać najlepsze rozwiązania dotyczące pracy z kalendarzami obsługującymi wiele epok, zobacz Praca z erami.
| Jeśli zadzwonisz | A provider jest |
Informacje o formatowaniu pochodzą z |
|---|---|---|
| Parse(String) | - | Bieżąca kultura (właściwośćDateTimeFormatInfo.CurrentInfo) |
| Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) | obiekt DateTimeFormatInfo | Określony obiekt DateTimeFormatInfo |
| Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) | null |
Bieżąca kultura (właściwośćDateTimeFormatInfo.CurrentInfo) |
| Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) | obiekt CultureInfo | Właściwość CultureInfo.DateTimeFormat |
| Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles) | Implementacja niestandardowej IFormatProvider | Metoda IFormatProvider.GetFormat |
Podczas formatowania informacji pochodzi z obiektu DateTimeFormatInfo, właściwość DateTimeFormatInfo.Calendar definiuje kalendarz używany w operacji analizowania.
Jeśli analizujesz ciąg daty i godziny przy użyciu obiektu DateTimeFormatInfo z dostosowanymi ustawieniami, które różnią się od standardowej kultury, użyj metody ParseExact zamiast metody Parse, 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. Z kolei metoda ParseExact wymaga jawnego wyznaczenia co najmniej jednego dokładnego wzorca analizy, które mogą zakończyć się powodzeniem. Aby uzyskać więcej informacji, zobacz sekcję "DateTimeFormatInfo and Dynamic Data" w temacie DateTimeFormatInfo.
Ważny
Należy pamiętać, że konwencje formatowania dla określonej kultury są dynamiczne i mogą ulec zmianie. Oznacza to, że analizowanie operacji zależnych od konwencji formatowania domyślnej (bieżącej) kultury lub określenie obiektu IFormatProvider reprezentującego kulturę inną niż niezmienna kultura może nieoczekiwanie zakończyć się niepowodzeniem, jeśli wystąpi którykolwiek z następujących elementów:
- Dane specyficzne dla kultury zmieniły się między wersjami głównymi lub pomocniczymi programu .NET Framework lub w wyniku aktualizacji istniejącej wersji programu .NET Framework.
- Dane specyficzne dla kultury odzwierciedlają preferencje użytkownika, które mogą się różnić od maszyny do maszyny lub sesji na sesję.
- Dane specyficzne dla kultury reprezentują kulturę zastępczą, która zastępuje ustawienia standardowej kultury lub kultury niestandardowej.
Aby zapobiec trudnościom podczas analizowania danych i ciągów czasu skojarzonych ze zmianami w danych kulturowych, można przeanalizować ciągi daty i godziny przy użyciu niezmiennej kultury lub wywołać metodę ParseExact 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 wartości DateTime w formacie binarnym.
Aby uzyskać więcej informacji, zobacz sekcję "Dane kultury dynamicznej" w temacie CultureInfo i sekcję "Utrwalanie wartości daty/godziny" w temacie DateTime.
Analizowanie i elementy stylu
Wszystkie przeciążenia Parse ignorują znaki wiodące, wewnętrzne lub końcowe odstępy w ciągu wejściowym (reprezentowane przez s w poniższej tabeli). Data i godzina mogą być w nawiasach z parą wiodących i końcowych znaków ZNAKU NUMERU ("#", U+0023) i mogą być na koniec z co najmniej jednym znakiem NULL (U+0000).
Ponadto przeciążenie Parse(String, IFormatProvider, DateTimeStyles) ma parametr styles, który składa się z co najmniej jednego elementu członkowskiego wyliczenia DateTimeStyles. Ten parametr definiuje sposób interpretowania s oraz sposobu konwertowania s operacji analizy na datę i godzinę. W poniższej tabeli opisano wpływ każdego elementu członkowskiego DateTimeStyles na operację analizowania.
| Element członkowski DateTimeStyles | Wpływ na konwersję |
|---|---|
| AdjustToUniversal | Analizuje s i w razie potrzeby konwertuje go na czas 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 flagę AssumeLocal, metoda analizuje ciąg, wywołuje ToUniversalTime, aby przekonwertować zwróconą wartość DateTime na UTC i ustawia właściwość Kind na DateTimeKind.Utc.- Jeśli s wskazuje, że reprezentuje 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 zwróconą wartość DateTime i ustawia właściwość Kind na DateTimeKind.Utc.- We wszystkich innych przypadkach flaga nie ma wpływu. |
| AllowInnerWhite | Ta wartość jest ignorowana. Odstęp wewnętrzny jest zawsze dozwolony w elementach daty i godziny s. |
| AllowLeadingWhite | Ta wartość jest ignorowana. Wiodące białe znaki są zawsze dozwolone w elementach daty i godziny s. |
| AllowTrailingWhite | Ta wartość jest ignorowana. Końcowy biały znak jest zawsze dozwolony w elementach daty i godziny 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ć przez podanie bardziej restrykcyjnej DateTimeStyles wartości wyliczenia, takiej jak None. |
| AssumeLocal | Określa, że jeśli s brakuje informacji o strefie czasowej, przyjmuje się czas lokalny. Chyba że flaga AdjustToUniversal jest obecna, właściwość Kind zwróconej wartości DateTime jest ustawiona na wartość DateTimeKind.Local. |
| AssumeUniversal | Określa, że jeśli s brakuje informacji o strefie czasowej, zakłada się, że utc. Chyba że flaga AdjustToUniversal jest obecna, metoda konwertuje zwróconą wartość DateTime z czasu UTC na czas lokalny i ustawia jej właściwość Kind na wartość DateTimeKind.Local. |
| None | Mimo że jest prawidłowa, ta wartość 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ść DateTime reprezentującą czas lokalny z właściwością Kind ustawioną na wartość DateTimeKind.Local. Zazwyczaj taki ciąg jest tworzony przez wywołanie metody DateTime.ToString(String) i przy użyciu specyfikatora formatu standardowego "o", "r" lub "u". |
Wartość zwracana i DateTime.Kind
Przeciążenia DateTime.Parse zwracają wartość DateTime, której właściwość Kind zawiera informacje o strefie czasowej. Może to wskazywać, że czas to:
- Uniwersalny czas koordynowany (System.DateTimeKind.Utc).
- Czas w lokalnej strefie czasowej (System.DateTimeKind.Local).
- Czas w nieznanej strefie czasowej (System.DateTimeKind.Unspecified).
Ogólnie rzecz biorąc, metoda Parse zwraca obiekt DateTime, którego właściwość Kind jest DateTimeKind.Unspecified. Jednak metoda Parse może również wykonać konwersję strefy czasowej i ustawić wartość właściwości Kind inaczej, w zależności od wartości parametrów s i styles:
| Jeśli | 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, a styles zawiera flagę AdjustToUniversal. |
Data i godzina jest konwertowana na uniwersalny czas koordynowany (UTC). | DateTimeKind.Utc |
s zawiera projekt strefy czasowej Z lub GMT, a styles zawiera flagę RoundtripKind. |
Data i godzina są interpretowane jako UTC. | DateTimeKind.Utc |
Poniższy przykład konwertuje ciągi daty zawierające informacje o strefie czasowej na godzinę 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 Kind daty i godziny podczas operacji formatowania i analizowania przy użyciu flagi DateTimeStyles.RoundtripKind. W poniższym przykładzie pokazano, jak flaga RoundtripKind wpływa na operację analizowania wartości DateTime, 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)
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
Konwertuje ciąg reprezentujący datę i godzinę na jego DateTime odpowiednik przy użyciu konwencji bieżącej kultury.
public:
static DateTime Parse(System::String ^ s);public static DateTime Parse (string s);static member Parse : string -> DateTimePublic Shared Function Parse (s As String) As DateTimeParametry
- s
- String
Ciąg zawierający datę i godzinę do przekonwertowania. Aby uzyskać więcej informacji, zobacz Ciąg do analizowania.
Zwraca
Obiekt, który jest odpowiednikiem daty i godziny zawartej w s.
Wyjątki
s jest null.
s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.
Przykłady
Poniższy przykład analizuje ciąg reprezentujący kilka 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, która jest AllowWhiteSpaces.
Obsługuje on wyjątek FormatException, 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 wartość DateTime, której właściwość Kind jest DateTimeKind.Local i konwertuje datę i godzinę w s na czas lokalny. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca wartość DateTime, której właściwość Kind jest DateTimeKind.Unspecified.
To przeciążenie próbuje przeanalizować s przy użyciu konwencji formatowania bieżącej kultury. Bieżąca kultura jest wskazywana przez właściwość CurrentCulture. Aby przeanalizować ciąg przy użyciu konwencji formatowania określonej kultury, wywołaj Parse(String, IFormatProvider) lub przeciążenia Parse(String, IFormatProvider, DateTimeStyles).
To przeciążenie próbuje przeanalizować s przy użyciu stylu DateTimeStyles.AllowWhiteSpaces.
Zobacz też
- TryParse
- CultureInfo
- DateTimeFormatInfo
- analizowanie ciągów daty i godziny w programie .NET Framework
- standardowe ciągi formatu daty i godziny
- niestandardowe ciągi formatu daty i godziny
Dotyczy
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
Analizuje zakres znaków w wartości.
public:
static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTimePublic Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTimeParametry
- s
- ReadOnlySpan<Char>
Zakres znaków do przeanalizowania.
- provider
- IFormatProvider
Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury na temat s.
Zwraca
Wynik analizowania s.
Implementuje
Dotyczy
Parse(String, IFormatProvider)
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu informacji o formacie specyficznym dla kultury.
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;public static DateTime Parse (string s, IFormatProvider provider);public static DateTime Parse (string s, IFormatProvider? provider);static member Parse : string * IFormatProvider -> DateTimePublic Shared Function Parse (s As String, provider As IFormatProvider) As DateTimeParametry
- s
- String
Ciąg zawierający datę i godzinę do przekonwertowania. Aby uzyskać więcej informacji, zobacz Ciąg do analizowania.
- provider
- IFormatProvider
Obiekt, który dostarcza informacje o formacie specyficznym dla kultury na temat s. Zobacz parsing i konwencje kulturowe
Zwraca
Obiekt, który jest odpowiednikiem daty i godziny zawartej w s określony przez provider.
Implementuje
Wyjątki
s jest null.
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 en-US, fr-FRi de-DE kultur. Pokazuje, że reprezentacje ciągu pojedynczej daty mogą być interpretowane 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 wartość DateTime, której właściwość Kind jest DateTimeKind.Local i konwertuje datę i godzinę w s na czas lokalny. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca wartość DateTime, której właściwość Kind jest DateTimeKind.Unspecified.
To przeciążenie próbuje przeanalizować s przy użyciu stylu DateTimeStyles.AllowWhiteSpaces.
Zobacz też
- TryParse
- CultureInfo
- DateTimeFormatInfo
- analizowanie ciągów daty i godziny w programie .NET Framework
- standardowe ciągi formatu daty i godziny
- niestandardowe ciągi formatu daty i godziny
Dotyczy
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
Konwertuje zakres pamięci, który zawiera ciąg reprezentujący datę i godzinę na jego DateTime odpowiednik 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 -> DateTimePublic Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeParametry
- s
- ReadOnlySpan<Char>
Zakres pamięci, który zawiera ciąg do przeanalizowana. Aby uzyskać więcej informacji, zobacz Ciąg do analizowania.
- provider
- IFormatProvider
Obiekt, który dostarcza informacje o formacie specyficznym dla kultury na temat s. Zobacz parsing i konwencje kulturowe
- styles
- DateTimeStyles
Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s dla operacji analizowania, 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
Obiekt, który jest odpowiednikiem daty i godziny zawartej w s, zgodnie z provider i styles.
Wyjątki
s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.
styles zawiera nieprawidłową kombinację wartości DateTimeStyles. Na przykład zarówno AssumeLocal, jak i AssumeUniversal.
Dotyczy
Parse(String, IFormatProvider, DateTimeStyles)
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
- Źródło:
- DateTime.cs
Konwertuje reprezentację ciągu daty i godziny na równoważną 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 -> DateTimePublic Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTimeParametry
- s
- String
Ciąg zawierający datę i godzinę do przekonwertowania. Aby uzyskać więcej informacji, zobacz Ciąg do analizowania.
- provider
- IFormatProvider
Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat s. Zobacz parsing i konwencje kulturowe
- styles
- DateTimeStyles
Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s dla operacji analizowania, 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
Obiekt, który jest odpowiednikiem daty i godziny zawartej w s, zgodnie z provider i styles.
Wyjątki
s jest null.
s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.
styles zawiera nieprawidłową kombinację wartości DateTimeStyles. Na przykład zarówno AssumeLocal, jak i AssumeUniversal.
Przykłady
Poniższy przykład przedstawia metodę Parse(String, IFormatProvider, DateTimeStyles) i wyświetla wartość właściwości Kind wynikowych wartości DateTime.
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 i ustawia właściwość Kind zwróconej wartości DateTime w następujący sposób:
| Jeśli | Konwersja strefy czasowej | Właściwość Kind |
|---|---|---|
s nie zawiera informacji o strefie czasowej. |
Żaden. | DateTimeKind.Unspecified |
s zawiera informacje o strefie czasowej. |
Czas w lokalnej strefie czasowej | DateTimeKind.Local |
s zawiera informacje o strefie czasowej, a styles zawiera flagę DateTimeStyles.AdjustToUniversal. |
Do uniwersalnego czasu koordynowanego (UTC) | DateTimeKind.Utc |
s zawiera projektant strefy czasowej Z lub GMT, a styles zawiera DateTimeStyles.RoundtripKind. |
Żaden. | DateTimeKind.Utc |
Zobacz też
- TryParse
- CultureInfo
- DateTimeFormatInfo
- analizowanie ciągów daty i godziny w programie .NET Framework
- standardowe ciągi formatu daty i godziny
- niestandardowe ciągi formatu daty i godziny
- Instrukcje: wartości daty i godziny rundy
Dotyczy
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla