DateTime.Parse Metoda

Definicja

Konwertuje ciąg reprezentujący datę i godzinę do DateTime odpowiednika.Converts the string representation of a date and time to its DateTime equivalent.

Przeciążenia

Parse(String)

Konwertuje ciąg reprezentujący datę i godzinę do DateTime równoważnej przy użyciu Konwencji bieżącej kultury wątku.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider)

Konwertuje ciąg reprezentujący datę i godzinę do DateTime odpowiednika przy użyciu informacji o formacie specyficznym dla kultury.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres pamięci, który zawiera ciąg reprezentujący datę i godzinę do jego DateTime odpowiednika przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles)

Konwertuje ciąg reprezentujący datę i godzinę na jej DateTime odpowiednik przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Przykłady

Liczne przykłady, które wywołują metodę DateTime.Parse, są przeplatane w części uwagi tego artykułu i w dokumentacji dotyczącej poszczególnych przeciążeń DateTime.Parse.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Uwaga

Niektóre C# przykłady w niniejszym artykule są uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.Some C# examples in this article run in the Try.NET inline code runner and playground. Wybierz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.Select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Lokalnej strefy czasowej z Try.NET wbudowany kod modułu uruchamiającego testy i placu zabaw jest uniwersalny czas koordynowany lub czasu UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Może to wpłynąć na zachowanie i dane wyjściowe przykłady ilustrujące DateTime, DateTimeOffset, i TimeZoneInfo typów i ich członków.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

Możesz również pobrać kompletny zestaw DateTime.Parse przykładów, które są uwzględnione w projekcie .NET Core 2,0 dla C# i projektu .NET Core 2,0 dla Visual Basic, w repozytorium GitHub/Samples.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Uwagi

W tej sekcji:In this section:

Jaką metodę wywołać?Which method do I call?

DoTo CallCall
Przeanalizuj ciąg daty i godziny przy użyciu Konwencji bieżącej kultury.Parse a date and time string by using the conventions of the current culture. Przeciążenie Parse(String)Parse(String) overload
Przeanalizuj ciąg daty i godziny przy użyciu konwencji określonej kultury.Parse a date and time string by using the conventions of a specific culture. Przeciążenie Parse(String, IFormatProvider) (patrz: analizowanie i konwencje kulturowe)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Przeanalizuj ciąg daty i godziny z specjalnymi elementami stylu (na przykład białych znakami lub bez białych znaków).Parse a date and time string with special style elements (such as white space or no white space). Przeciążenie Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Przeanalizuj ciąg daty i godziny, który musi być w określonym formacie.Parse a date and time string that must be in a particular format. DateTime.ParseExact lub DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Przeanalizuj ciąg daty i godziny i przeprowadź konwersję na czas UTC lub czasu lokalnego.Parse a date and time string and perform a conversion to UTC or local time. Przeciążenie Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Przeanalizuj ciąg daty i godziny bez obsługi wyjątków.Parse a date and time string without handling exceptions. DateTime.TryParse, MetodaDateTime.TryParse method
Przywróć (rundy) wartość daty i godziny utworzona przez operację formatowania.Restore (round-trip) a date and time value created by a formatting operation. Przekaż ciąg formatu standardowego "o" lub "r" do metody ToString(String) i Wywołaj Przeciążenie Parse(String, IFormatProvider, DateTimeStyles) za pomocą DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Przeanalizuj ciąg daty i godziny w ustalonym formacie między maszynami (i możliwymi do kultury) granicami.Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExact lub DateTime.TryParseExact MetodaDateTime.ParseExact or DateTime.TryParseExact method

Ciąg do analizyThe string to parse

Metoda Parse próbuje przekonwertować ciąg reprezentujący wartość daty i godziny na odpowiedni DateTime.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Próbuje on całkowicie przeanalizować ciąg wejściowy bez zgłaszania wyjątku FormatException.It tries to parse the input string completely without throwing a FormatException exception.

Ważne

Jeśli operacja analizowania nie powiedzie się ze względu na nierozpoznany format ciągu, Metoda Parse zgłasza FormatException, a metoda TryParse zwraca false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Ponieważ obsługa wyjątków może być kosztowna, należy użyć Parse, gdy oczekiwane jest wykonanie operacji analizowania, ponieważ źródło danych wejściowych jest zaufane.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse jest preferowany, gdy błędy analizy są prawdopodobnie, szczególnie ze względu na to, że źródło danych wejściowych nie jest zaufane lub uzasadnione są rozsądne wartości domyślne dla ciągów, które nie są analizowane pomyślnie.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

Ciąg, który ma być analizowany, może przyjmować jedną z następujących form:The string to be parsed can take any of the following forms:

  • Ciąg z datą i składnikiem czasu.A string with a date and a time component.

  • Ciąg z datą, ale bez składnika godziny.A string with a date but no time component. Jeśli nie jest obecny składnik czasu, metoda przyjmuje 12:00 północy.If the time component is absent, the method assumes 12:00 midnight. Jeśli składnik daty ma rok dwucyfrowy, 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 niezerowym argumentem provider).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Ciąg ze składnikiem Date, który zawiera tylko miesiąc i rok, ale nie składnik.A string with a date component that includes only the month and the year but no day component. Metoda przyjmuje pierwszy dzień miesiąca.The method assumes the first day of the month.

  • Ciąg ze składnikiem Date, który zawiera tylko miesiąc i dzień, ale nie składnik roku.A string with a date component that includes only the month and the day but no year component. Metoda przyjmuje bieżący rok.The method assumes the current year.

  • Ciąg z czasem, ale nie ze składnikiem daty.A string with a time but no date component. Metoda przyjmuje bieżącą datę, chyba że wywołasz Przeciążenie Parse(String, IFormatProvider, DateTimeStyles) i zawiera DateTimeStyles.NoCurrentDateDefault w argumencie styles, w takim przypadku metoda przyjmuje datę 1 stycznia 0,001.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Ciąg ze składnikiem czasu, który zawiera tylko oznaczenie Hour i AM/PM bez składnika Date.A string with a time component that includes only the hour and an AM/PM designator, with no date component. Metoda przyjmuje bieżącą datę i godzinę bez minut i nie sekund.The method assumes the current date and a time with no minutes and no seconds. Można zmienić to zachowanie, wywołując Przeciążenie Parse(String, IFormatProvider, DateTimeStyles) i uwzględniając DateTimeStyles.NoCurrentDateDefault w argumencie styles, w takim przypadku metoda przyjmuje datę 1 stycznia 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Ciąg, który zawiera informacje o strefie czasowej i jest zgodny z normą ISO 8601.A string that includes time zone information and conforms to ISO 8601. W poniższych przykładach pierwszy ciąg Określa uniwersalny czas koordynowany (UTC), a drugi określa czas w strefie czasowej, który jest siedmiu godzin wcześniejszy niż UTC:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

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

  • Ciąg, który zawiera oznaczenie GMT i jest zgodny z formatem formatu RFC 1123; na przykład:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "SAT, 01 lis 2008 19:35:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Ciąg zawierający datę i godzinę wraz z informacjami o przesunięciu strefy czasowej; na przykład:A string that includes the date and time along with time zone offset information; for example:

    "03/01/2009 05:42:00 -5:00""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, która w tym przypadku jest kulturą en-US:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

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

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ę analizy (zobacz temat analizy i konwencje kulturowe), Metoda Parse analizuje ciąg pomyślnie.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Jeśli ciąg wejściowy reprezentuje dzień przestępny w roku, w którym nie przestępno, metoda zgłasza FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Ponieważ metoda Parse próbuje przeanalizować ciąg reprezentujący datę i godzinę przy użyciu reguł formatowania bieżącej lub określonej kultury, próba przeanalizowania ciągu dla różnych kultur może zakończyć się niepowodzeniem.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. Aby przeanalizować określony format daty i godziny dla różnych ustawień regionalnych, użyj jednego z przeciążeń metody DateTime.ParseExact i podaj specyfikator formatu.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Konwencje analizy i kulturyParsing and cultural conventions

Wszystkie przeciążenia metody Parse są zależne od kultury, chyba że ciąg, który ma być analizowany (który jest reprezentowany przez s w poniższej tabeli), jest zgodny ze wzorcem ISO 8601.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. Operacja analizowania używa informacji o formatowaniu w obiekcie DateTimeFormatInfo, który jest wyprowadzany w następujący sposób:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Ważne

Ery kalendarza japońskiego opierają się na reign imperatora i w związku z tym są powinna się zmienić.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Na przykład 1 maja 2019 oznaczony początku ery Reiwa JapaneseCalendar i JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Zmiana era ma wpływ na wszystkie aplikacje, które używają tych kalendarzy.Such a change of era affects all applications that use these calendars. Zobacz obsługi nowej ery usług w kalendarza japońskiego na platformie .NET uzyskać więcej informacji, jak i do określenia aplikacji, których dotyczy problem.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Zobacz przygotowanie aplikacji w taki sposób, aby ta zmiana era japoński instrukcje dotyczące testowania aplikacji w systemach Windows w celu zapewnienia ich gotowości, aby ta zmiana era.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Zobacz Praca z erami dla funkcji na platformie .NET, które obsługują kalendarzach z erami wielu i najlepsze rozwiązania, gdy praca z kalendarzami, które obsługują wiele er.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

W przypadku wywołaniaIf you call I provider jestAnd provider is Informacje o formatowaniu są wyprowadzane zFormatting information is derived from
Parse(String) - Bieżąca kultura wątku (DateTimeFormatInfo.CurrentInfo Właściwość)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Obiekt DateTimeFormatInfoa DateTimeFormatInfo object Określony DateTimeFormatInfo obiektThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Bieżąca kultura wątku (DateTimeFormatInfo.CurrentInfo Właściwość)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Obiekt CultureInfoa CultureInfo object Właściwość CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) lub Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Implementacja niestandardowego IFormatProviderCustom IFormatProvider implementation Metoda IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Gdy informacje o formatowaniu są wyprowadzane z obiektu DateTimeFormatInfo, właściwość DateTimeFormatInfo.Calendar definiuje kalendarz używany w operacji analizowania.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

W przypadku analizowania ciągu daty i godziny przy użyciu obiektu DateTimeFormatInfo z dostosowanymi ustawieniami, które różnią się od tych w standardowej kulturze, użyj metody ParseExact zamiast metody Parse, aby zwiększyć prawdopodobieństwo pomyślnej konwersji.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Niestandardowy ciąg daty i godziny może być skomplikowany i trudny do analizy.A non-standard date and time string can be complicated and difficult to parse. Metoda Parse próbuje przeanalizować ciąg za pomocą kilku niejawnych wzorców analizy, co może zakończyć się niepowodzeniem.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Z kolei Metoda ParseExact wymaga jawnie wyznaczania co najmniej jednego dokładnego wzorca analizy, które może się powieść.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Aby uzyskać więcej informacji, zobacz sekcję "DateTimeFormatInfo i dane dynamiczne" w temacie DateTimeFormatInfo.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Ważne

Należy zauważyć, że konwencje formatowania dla określonej kultury są dynamiczne i mogą ulec zmianie.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. Oznacza to, że operacje analizowania, które są zależne od Konwencji formatowania domyślnej (bieżącej) kultury lub określające obiekt IFormatProvider, który reprezentuje kulturę inną niż Niezmienna kultura może nieoczekiwanie zakończyć się niepowodzeniem, jeśli wystąpi którykolwiek z następujących wystąpień:This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Dane specyficzne dla kultury uległy zmianie między głównymi lub pomocniczymi wersjami .NET Framework lub w wyniku aktualizacji istniejącej wersji .NET Framework.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Dane specyficzne dla kultury odzwierciedlają preferencje użytkownika, które mogą się różnić w zależności od maszyny lub sesji do sesji.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Dane specyficzne dla kultury przedstawiają kulturę zastępczą, która zastępuje ustawienia kultury standardowej lub kultury niestandardowej.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Aby zapobiec problemom z analizą danych i ciągów czasu, które są związane ze zmianami w danych kultury, można analizować 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 analizy.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. W przypadku serializacji i deserializacji danych daty i godziny można użyć Konwencji formatowania niezmiennej kultury lub można serializować i zdeserializować wartości DateTime w formacie binarnym.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

Aby uzyskać więcej informacji, zobacz sekcję "dane kultury dynamicznej" w temacie CultureInfo i sekcję "trwałe wartości DateTime" w temacie DateTime.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Analizowanie i elementy styluParsing and style elements

Wszystkie Parse przeciążenia ignorują wiodące, wewnętrzne lub końcowe znaki białych znaków w ciągu wejściowym (który jest reprezentowany przez s w poniższej tabeli).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). Datę i godzinę można przenawiasować za pomocą pary wiodących i końcowych znaków numeru ("#", U + 0023) i można je kończyć z co najmniej jednym znakiem NULL (U + 0000).The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (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.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Ten parametr definiuje sposób interpretowania s i sposobu, w jaki operacja analizy powinna być konwertowana s na datę i godzinę.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. W poniższej tabeli opisano wpływ każdego elementu członkowskiego DateTimeStyles na operację analizy.The following table describes the effect of each DateTimeStyles member on the parse operation.

Element członkowski DateTimeStylesDateTimeStyles member Wpływ na konwersjęEffect on conversion
AdjustToUniversal Analizuje s i, w razie potrzeby, konwertuje ją na czas UTC w następujący sposób:Parses s and, if necessary, converts it to UTC, as follows:

-Jeśli s obejmuje 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 skonwertować zwróconą DateTime wartość na czas UTC i ustawi właściwość Kind na DateTimeKind.Utc.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to 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 w zwracanej wartości DateTime i ustawia właściwość Kind na DateTimeKind.Utc.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
We wszystkich innych przypadkach flaga nie ma żadnego wpływu.- In all other cases, the flag has no effect.
AllowInnerWhite Ta wartość jest ignorowana.This value is ignored. Wewnętrzny biały znak jest zawsze dozwolony w elementach daty i godziny s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Ta wartość jest ignorowana.This value is ignored. Wiodący biały znak jest zawsze dozwolony w elementach daty i godziny s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Ta wartość jest ignorowana.This value is ignored. Końcowy biały znak jest zawsze dozwolony w elementach daty i godziny s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Określa, że s mogą zawierać wiodące, wewnętrzne i końcowe białe znaki.Specifies that s may contain leading, inner, and trailing white spaces. To zachowanie domyślne.This is the default behavior. Nie można go zastąpić przez dostarczenie bardziej restrykcyjnej wartości wyliczenia DateTimeStyles takiej jak None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Określa, że jeśli s nie zawiera żadnych informacji o strefie czasowej, założono czas lokalny.Specifies that if s lacks any time zone information, local time is assumed. Jeśli flaga AdjustToUniversal nie istnieje, właściwość Kind zwróconej wartości DateTime jest ustawiona na DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Określa, że jeśli s brak informacji o strefie czasowej, zakłada się, że jest UTC.Specifies that if s lacks any time zone information, UTC is assumed. Jeśli flaga AdjustToUniversal nie jest obecna, Metoda konwertuje zwróconą wartość DateTime z czasu UTC na czas lokalny i ustawi jej Właściwość Kind na DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Choć ważna, wartość ta jest ignorowana.Although valid, this value is ignored.
RoundtripKind W przypadku ciągów zawierających informacje o strefie czasowej program próbuje zapobiec konwersji ciągu daty i godziny na wartość DateTime, która reprezentuje czas lokalny z właściwością Kind ustawioną na DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to 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".Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

Wartość zwracana i DateTime. KindThe return value and DateTime.Kind

Przeciążenia DateTime.Parse zwracają wartość DateTime, której Właściwość Kind zawiera informacje o strefie czasowej.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Może to oznaczać, że czas:It can indicate that the time is:

Ogólnie rzecz biorąc Metoda Parse zwraca obiekt DateTime, którego właściwość Kind jest DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Jednak Metoda Parse może również wykonywać konwersję strefy czasowej i ustawiać wartość właściwości Kind w różny sposób, w zależności od wartości s i styles parametrów:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

Jeśli użytkownikIf Konwersja strefy czasowejTime zone conversion Właściwość KindKind property
s zawiera informacje o strefie czasowej.s contains time zone information. Data i godzina są konwertowane na godzinę w lokalnej strefie czasowej.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s zawiera informacje o strefie czasowej, a styles zawiera flagę AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. Data i godzina są konwertowane na uniwersalny czas koordynowany (UTC).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s zawiera oznaczenie strefy czasowej Z lub GMT, a styles zawiera flagę RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. Data i godzina są interpretowane jako czas UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

Poniższy przykład konwertuje ciągi dat, które zawierają informacje o strefie czasowej, do godziny w lokalnej strefie czasowej:The following example converts date strings that contain time zone information to the time in the local time zone:

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                                             
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żesz również zachować wartość właściwości Kind daty i godziny podczas operacji formatowania i analizowania przy użyciu flagi DateTimeStyles.RoundtripKind.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. Poniższy przykład ilustruje, jak flaga RoundtripKind ma wpływ na operację analizowania na DateTime wartości, które są konwertowane na ciągi przy użyciu specyfikatora formatu "o", "r" lub "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   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.      
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 ciąg reprezentujący datę i godzinę do DateTime równoważnej przy użyciu Konwencji bieżącej kultury wątku.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

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ć.A string that contains a date and time to convert. Aby uzyskać więcej informacji , zobacz ciąg, który ma zostać przeanalizowany .See The string to parse for more information.

Zwraca

Obiekt, który jest odpowiednikiem daty i godziny zawartej w s.An object that is equivalent to the date and time contained in s.

Wyjątki

Parametr s ma wartość null.s is null.

s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.s does not contain a valid string representation of a date and time.

Uwagi

Jeśli s zawiera informacje o strefie czasowej, ta metoda zwraca DateTime wartość, której Właściwość Kind jest DateTimeKind.Local i konwertuje datę i godzinę w s na czas lokalny.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca DateTime wartość, której Właściwość Kind jest DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

To Przeciążenie próbuje przeanalizować s przy użyciu Konwencji formatowania bieżącej kultury.This overload attempts to parse s by using the formatting conventions of the current culture. Bieżąca kultura jest wskazywana przez właściwość CurrentCulture.The current culture is indicated by the CurrentCulture property. 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 parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

To Przeciążenie próbuje przeanalizować s przy użyciu stylu DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

PrzykładExample

Poniższy przykład analizuje ciąg reprezentujący kilka wartości daty i godziny według:The following example parses the string representation of several date and time values by:

  • Przy użyciu domyślnego dostawcy formatu, który zapewnia konwencje formatowania bieżącej kultury wątku komputera używanego do tworzenia przykładowych danych wyjściowych.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. Dane wyjściowe z tego przykładu odzwierciedlają konwencje formatowania kultury en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Przy użyciu wartości stylu domyślnego, która jest AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Obsługuje wyjątek FormatException, który jest generowany, gdy metoda próbuje przeanalizować ciąg reprezentujący datę i godzinę przy użyciu innych Konwencji formatowania kultury.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. Pokazano również, jak pomyślnie analizować wartość daty i godziny, która nie używa Konwencji formatowania bieżącej kultury wątku.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

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

Zobacz też

Parse(String, IFormatProvider)

Konwertuje ciąg reprezentujący datę i godzinę do DateTime odpowiednika przy użyciu informacji o formacie specyficznym dla kultury.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::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ć.A string that contains a date and time to convert. Aby uzyskać więcej informacji , zobacz ciąg, który ma zostać przeanalizowany .See The string to parse for more information.

provider
IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury dotyczące s.An object that supplies culture-specific format information about s. Zobacz sekcję analizowanie i konwencje kulturoweSee Parsing and cultural conventions

Zwraca

Obiekt, który jest odpowiednikiem daty i godziny zawartej w s określonym przez provider.An object that is equivalent to the date and time contained in s as specified by provider.

Wyjątki

Parametr s ma wartość null.s is null.

s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.s does not contain a valid string representation of a date and time.

Uwagi

Jeśli s zawiera informacje o strefie czasowej, ta metoda zwraca DateTime wartość, której Właściwość Kind jest DateTimeKind.Local i konwertuje datę i godzinę w s na czas lokalny.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. W przeciwnym razie nie wykonuje konwersji strefy czasowej i zwraca DateTime wartość, której Właściwość Kind jest DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

To Przeciążenie próbuje przeanalizować s przy użyciu stylu DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

PrzykładExample

Poniższy przykład analizuje tablicę ciągów dat przy użyciu konwencji en-US, fr-FR i de-DE kultury.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Pokazuje, że reprezentacje ciągu pojedynczej daty mogą być interpretowane inaczej w różnych kulturach.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

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

Zobacz też

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres pamięci, który zawiera ciąg reprezentujący datę i godzinę do jego DateTime odpowiednika przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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 = null, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametry

s
ReadOnlySpan<Char>

Zakres pamięci, który zawiera ciąg do analizy.The memory span that contains the string to parse. Aby uzyskać więcej informacji , zobacz ciąg, który ma zostać przeanalizowany .See The string to parse for more information.

provider
IFormatProvider

Obiekt, który dostarcza informacje o formacie specyficznym dla kultury dotyczące s.An object that supplies culture-specific format information about s. Zobacz sekcję analizowanie i konwencje kulturoweSee Parsing and cultural conventions

styles
DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s, aby operacja analizy zakończyła się powodzeniem, i która definiuje sposób interpretacji przeanalizowanej daty w odniesieniu do bieżącej strefy czasowej lub bieżącej daty.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Typową wartością do określenia jest None.A typical value to specify is None.

Zwraca

Obiekt, który jest równoważny dacie i godzinie zawartej w s, określony przez provider i styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Wyjątki

s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.s does not contain a valid string representation of a date and time.

styles zawiera nieprawidłową kombinację wartości DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Na przykład zarówno AssumeLocal, jak i AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Konwertuje ciąg reprezentujący datę i godzinę na jej DateTime odpowiednik przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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);
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ć.A string that contains a date and time to convert. Aby uzyskać więcej informacji , zobacz ciąg, który ma zostać przeanalizowany .See The string to parse for more information.

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury dotyczące s.An object that supplies culture-specific formatting information about s. Zobacz sekcję analizowanie i konwencje kulturoweSee Parsing and cultural conventions

styles
DateTimeStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s, aby operacja analizy zakończyła się powodzeniem, i która definiuje sposób interpretacji przeanalizowanej daty w odniesieniu do bieżącej strefy czasowej lub bieżącej daty.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Typową wartością do określenia jest None.A typical value to specify is None.

Zwraca

Obiekt, który jest równoważny dacie i godzinie zawartej w s, określony przez provider i styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Wyjątki

Parametr s ma wartość null.s is null.

s nie zawiera prawidłowej reprezentacji ciągu daty i godziny.s does not contain a valid string representation of a date and time.

styles zawiera nieprawidłową kombinację wartości DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Na przykład zarówno AssumeLocal, jak i AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Uwagi

To Przeciążenie metody przekształca datę i godzinę w s i ustawia właściwość Kind zwróconej wartości DateTime w następujący sposób:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

Jeśli użytkownikIf Konwersja strefy czasowejTime zone conversion Właściwość KindKind property
s nie zawiera informacji o strefie czasowej.s contains no time zone information. Brak.None. DateTimeKind.Unspecified
s zawiera informacje o strefie czasowej.s contains time zone information. Na godzinę w lokalnej strefie czasowejTo the time in the local time zone DateTimeKind.Local
s zawiera informacje o strefie czasowej, a styles zawiera flagę DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. Na uniwersalny czas koordynowany (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s zawiera oznaczenie strefy czasowej Z lub GMT, a styles zawiera DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. Brak.None. DateTimeKind.Utc

PrzykładExample

Poniższy przykład demonstruje metodę Parse(String, IFormatProvider, DateTimeStyles) i wyświetla wartość właściwości Kind w wyniku DateTime wartości.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

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

Zobacz też

Dotyczy