DateTime.Parse Metoda

Definice

Převede řetězcové vyjádření data a času na jeho ekvivalent DateTime.Converts the string representation of a date and time to its DateTime equivalent.

Přetížení

Parse(String)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí konvencí aktuální jazykové verze vlákna.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)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí informací o formátování specifické pro jazykovou verzi.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Převede rozsah paměti obsahující řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátování specifických pro jazykovou verzi a stylu formátování.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)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí informací o formátování specifických pro jazykovou verzi a stylu formátování.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Příklady

Mnohé příklady, které volají metodu DateTime.Parse, jsou proložené v celém oddílu poznámky tohoto článku a v dokumentaci pro jednotlivá DateTime.Parse přetížení.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.

Poznámka

Některé C# spuštění příkladů v tomto článku v Try.NET runner a playground vloženého kódu.Some C# examples in this article run in the Try.NET inline code runner and playground. Vyberte spustit tlačítko spustit příklad v interaktivním okně.Select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Místní časové pásmo z Try.NET vložený kód spouštěče a playground je koordinovaný světový čas nebo čas UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. To může mít vliv chování a výstup příklady znázorňující, DateTime, DateTimeOffset, a TimeZoneInfo typů a jejich členy.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

Můžete si také stáhnout kompletní sadu DateTime.Parse příklady, které jsou součástí projektu .NET Core 2,0 pro C# a projekt .NET Core 2,0 pro Visual Basic, v úložišti 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.

Poznámky

V této části:In this section:

Jakou metodu mám volat?Which method do I call?

ProTo VoláníCall
Analyzujte řetězec data a času pomocí konvencí aktuální jazykové verze.Parse a date and time string by using the conventions of the current culture. přetížení Parse(String)Parse(String) overload
Analyzujte řetězec data a času pomocí konvencí konkrétní jazykové verze.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider) přetížení (viz Analýza a kulturní konvence)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analyzujte řetězec data a času pomocí speciálních prvků stylu (například prázdný znak nebo prázdné místo).Parse a date and time string with special style elements (such as white space or no white space). přetížení Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analyzujte řetězec data a času, který musí být v určitém formátu.Parse a date and time string that must be in a particular format. DateTime.ParseExact nebo DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analyzujte řetězec data a času a proveďte převod na světový čas UTC nebo místního času.Parse a date and time string and perform a conversion to UTC or local time. přetížení Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analyzuje řetězec data a času bez zpracování výjimek.Parse a date and time string without handling exceptions. DateTime.TryParse – metodaDateTime.TryParse method
Obnovení (round-trip) hodnota data a času vytvořená operací formátování.Restore (round-trip) a date and time value created by a formatting operation. Předání řetězce standardního formátu "o" nebo "r" do metody ToString(String) a volání přetížení Parse(String, IFormatProvider, DateTimeStyles) 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
Analyzuje řetězec data a času v pevném formátu mezi počítačem (a případně kulturní) hranicí.Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. Metoda DateTime.ParseExact nebo DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact method

Řetězec určený k analýzeThe string to parse

Metoda Parse se pokusí převést řetězcovou reprezentaci hodnoty data a času na jeho DateTime ekvivalent.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Pokusí se úplně analyzovat vstupní řetězec bez vyvolání výjimky FormatException.It tries to parse the input string completely without throwing a FormatException exception.

Důležité

Pokud operace analýzy neproběhne úspěšně z důvodu nerozpoznaného formátu řetězce, metoda Parse vyvolá FormatException, zatímco metoda TryParse vrátí false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Protože zpracování výjimek může být nákladné, měli byste použít Parse, pokud se očekává, že operace analýzy bude úspěšná, protože vstupní zdroj je důvěryhodný.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 je vhodnější při analýze selhání, zejména proto, že vstupní zdroj není důvěryhodný nebo že máte přiměřené výchozí hodnoty, které nahradí řetězce, které se neanalyzují úspěšně.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.

Řetězec, který se má analyzovat, může mít některou z následujících forem:The string to be parsed can take any of the following forms:

  • Řetězec s komponentou data a času.A string with a date and a time component.

  • Řetězec s datem, ale nejedná se o komponentu času.A string with a date but no time component. Pokud časová komponenta chybí, metoda předpokládá 12:00 půlnoc.If the time component is absent, the method assumes 12:00 midnight. Pokud má komponenta data dva číslice rok, je převedena na rok na základě Calendar.TwoDigitYearMax aktuálního kalendáře aktuální jazykové verze nebo aktuálního kalendáře zadané jazykové verze (Pokud použijete přetížení s provider argumentem, který není null).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).

  • Řetězec s komponentou Date, která zahrnuje pouze měsíc a rok, ale komponentu žádného dne.A string with a date component that includes only the month and the year but no day component. Metoda předpokládá první den v měsíci.The method assumes the first day of the month.

  • Řetězec s komponentou Date, která obsahuje pouze měsíc a den, ale nezahrnuje komponentu year.A string with a date component that includes only the month and the day but no year component. Metoda předpokládá aktuální rok.The method assumes the current year.

  • Řetězec, který neobsahuje komponentu data a času.A string with a time but no date component. Metoda předpokládá aktuální datum, pokud nevoláte metodu Parse(String, IFormatProvider, DateTimeStyles) Overload a zahrnete DateTimeStyles.NoCurrentDateDefault do argumentu styles. v takovém případě metoda předpokládá datum 1. ledna 0001.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.

  • Řetězec s časovou komponentou, která obsahuje pouze hodinu a označení AM/PM bez komponenty data.A string with a time component that includes only the hour and an AM/PM designator, with no date component. Metoda předpokládá aktuální datum a čas bez minut a sekund.The method assumes the current date and a time with no minutes and no seconds. Toto chování můžete změnit voláním přetížení Parse(String, IFormatProvider, DateTimeStyles) a zahrnutím DateTimeStyles.NoCurrentDateDefault do argumentu styles. v takovém případě metoda předpokládá datum 1. ledna 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.

  • Řetězec, který obsahuje informace o časovém pásmu a odpovídá normě ISO 8601.A string that includes time zone information and conforms to ISO 8601. V následujících příkladech první řetězec označuje koordinovaný světový čas (UTC) a druhý určí čas v časovém pásmu, které je sedm hodin starší než 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.0000000 Z""2008-11-01T19:35:00.0000000Z"
    "2008-11-01T19:35:00.0000000-07:00""2008-11-01T19:35:00.0000000-07:00"

  • Řetězec, který obsahuje označení GMT a odpovídá formátu času RFC 1123; například:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

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

  • Řetězec, který obsahuje datum a čas spolu s informacemi o posunu časového pásma; například: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"

Následující příklad analyzuje řetězce v každém z těchto formátů pomocí formátovacích úmluv aktuální jazykové verze, což je v tomto případě jazyková verze 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

Pokud vstupní řetězec představuje přestupný den v přestupném roce v kalendáři použitém metodou analýzy (viz Analýza a kulturní konvence), Parse metoda analyzuje řetězec úspěšně.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. Pokud vstupní řetězec představuje přestupný den v přestupném roce, vyvolá metoda FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Vzhledem k tomu, že se metoda Parse pokusí analyzovat řetězcové vyjádření data a času pomocí pravidel formátování aktuální nebo zadané jazykové verze, pokus o analýzu řetězce v různých jazykových verzích může selhat.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. Chcete-li analyzovat konkrétní formát data a času v různých národních prostředích, použijte jedno z přetížení metody DateTime.ParseExact a poskytněte specifikátor formátu.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.

Analýzy a kulturní konvenceParsing and cultural conventions

Všechna přetížení Parse metody jsou závislá na jazykové verzi, pokud řetězec, který se má analyzovat (který je reprezentován s v následující tabulce), odpovídá vzoru 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. Operace analýzy používá informace o formátování v objektu DateTimeFormatInfo, který je odvozen následujícím způsobem:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Důležité

Větší počet období v japonské kalendářích jsou založené na císaře a proto se neočekává změna.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Například 1. května 2019 označené začátku období Reiwa ve JapaneseCalendar a JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Tuto změnu období ovlivňuje všechny aplikace, které používají tyto kalendáře.Such a change of era affects all applications that use these calendars. Zobrazit zpracování do nové éry v japonské kalendáře v rozhraní .NET Další informace a na zjištění, zda jsou vliv na vaše aplikace.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Zobrazit Příprava aplikace pro změnu japonské období informace o testování aplikací v systémech Windows pro zajištění jejich připravenosti změna éry.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. Zobrazit práce s obdobími pro funkce v rozhraní .NET, které podporují kalendářích s obdobími více a osvědčené postupy při práci s kalendáře, které podporují větší počet období.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.

Pokud zavoláteIf you call A provider jeAnd provider is Informace o formátování jsou odvozeny zFormatting information is derived from
Parse(String) - Aktuální jazyková verze vlákna (vlastnostDateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) objekt DateTimeFormatInfoa DateTimeFormatInfo object Zadaný objekt DateTimeFormatInfoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Aktuální jazyková verze vlákna (vlastnostDateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) objekt CultureInfoa CultureInfo object Vlastnost CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Vlastní implementace IFormatProviderCustom IFormatProvider implementation Metoda IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Pokud jsou informace o formátování odvozeny z objektu DateTimeFormatInfo, vlastnost DateTimeFormatInfo.Calendar definuje kalendář použitý v operaci analýzy.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Pokud analyzujete řetězec data a času pomocí objektu DateTimeFormatInfo s přizpůsobenými nastaveními, která jsou odlišná od těch standardní jazykové verze, použijte metodu ParseExact namísto metody Parse pro zlepšení pravděpodobnosti úspěšného převodu.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. Nestandardní řetězec data a času může být složitý a obtížné ho analyzovat.A non-standard date and time string can be complicated and difficult to parse. Metoda Parse se pokusí analyzovat řetězec s několika implicitními vzory analýzy, které mohou selhat.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Naproti tomu ParseExact metoda vyžaduje explicitně určit jeden nebo více přesných vzorů analýz, které jsou pravděpodobně úspěšné.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Další informace naleznete v části "DateTimeFormatInfo and Dynamic Data" v tématu DateTimeFormatInfo.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Důležité

Všimněte si, že konvence formátování pro konkrétní jazykovou verzi jsou dynamické a může se změnit.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. To znamená, že operace analýzy, které závisí na konvencích formátování výchozí (aktuální) jazykové verze nebo které určují IFormatProvider objekt, který představuje jinou jazykovou verzi, než je neutrální jazyková verze, může neočekávaně selhat, pokud dojde k některé z následujících situací: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:

  • Data specifická pro jazykovou verzi se změnila mezi hlavními nebo podverzemi .NET Framework nebo jako výsledek aktualizace existující verze .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.
  • Data specifická pro jazykovou verzi odpovídají uživatelským preferencím, které se můžou lišit od počítače po počítač nebo relaci až po relaci.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Data specifická pro jazykovou verzi představují náhradní jazykovou verzi, která přepisuje nastavení standardní jazykové verze nebo vlastní jazykové verze.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Chcete-li zabránit problémům při analýze dat a časových řetězců, které jsou spojeny se změnami v kulturních data, můžete analyzovat řetězce data a času pomocí invariantní jazykové verze, nebo můžete zavolat metodu ParseExact nebo TryParseExact a zadat přesný formát řetězce, který chcete analyzovat.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. Pokud provádíte serializaci a deserializaci dat data a času, můžete použít konvence formátování invariantní jazykové verze, nebo můžete serializovat a deserializovat DateTime hodnotu v binárním formátu.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.

Další informace naleznete v části "dynamická jazyková data" v tématu CultureInfo a v části "trvalé hodnoty DateTime" v tématu DateTime.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Analýza a elementy styluParsing and style elements

Všechna Parse přetížení ignorují počáteční, vnitřní nebo koncové prázdné znaky ve vstupním řetězci (které jsou reprezentovány s v následující tabulce).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). Datum a čas může být začínat dvojicí znakem začátku a koncového čísla ("#", U + 0023) a může být koncová s jedním nebo více znaky 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).

Kromě toho má přetížení Parse(String, IFormatProvider, DateTimeStyles) styles parametr, který se skládá z jednoho nebo více členů výčtu DateTimeStyles.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Tento parametr definuje, jak by měla být interpretace s a jak by měla operace analýzy převádět s na datum a čas.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. Následující tabulka popisuje účinek každého člena DateTimeStyles na operaci analýzy.The following table describes the effect of each DateTimeStyles member on the parse operation.

Člen DateTimeStylesDateTimeStyles member Vliv na převodEffect on conversion
AdjustToUniversal Analyzuje s a v případě potřeby převede na čas UTC následujícím způsobem:Parses s and, if necessary, converts it to UTC, as follows:

-Pokud s zahrnuje posun časového pásma nebo pokud s neobsahuje žádné informace o časovém pásmu, ale styles obsahuje příznak AssumeLocal, metoda analyzuje řetězec, volá ToUniversalTime k převedení vrácené DateTime hodnoty na UTC a nastaví vlastnost 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.
-Pokud s označuje, že představuje čas UTC, nebo pokud s neobsahuje informace o časovém pásmu, ale styles obsahuje příznak AssumeUniversal, metoda analyzuje řetězec, neprovede žádnou konverzi časového pásma u vrácené DateTime hodnoty a nastaví vlastnost 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.
– Ve všech ostatních případech příznak nemá žádný vliv.- In all other cases, the flag has no effect.
AllowInnerWhite Tato hodnota je ignorována.This value is ignored. Vnitřní prázdné znaky jsou vždy povoleny v prvcích data a času s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Tato hodnota je ignorována.This value is ignored. Počáteční prázdné místo je vždy povoleno v prvcích data a času s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Tato hodnota je ignorována.This value is ignored. Koncové prázdné znaky jsou vždy povoleny v prvcích data a času s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Určuje, že s může obsahovat úvodní, vnitřní a koncové prázdné znaky.Specifies that s may contain leading, inner, and trailing white spaces. Toto je výchozí chování.This is the default behavior. Nedá se přepsat tím, že poskytuje více omezující DateTimeStyles hodnotu výčtu, jako je například None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Určuje, že pokud s nemá žádné informace o časovém pásmu, předpokládá se místní čas.Specifies that if s lacks any time zone information, local time is assumed. Pokud není k dispozici příznak AdjustToUniversal, vlastnost Kind vrácené DateTime hodnoty je nastavena na DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Určuje, že pokud s nemá žádné informace o časovém pásmu, předpokládá se čas UTC.Specifies that if s lacks any time zone information, UTC is assumed. Pokud příznak AdjustToUniversal není k dispozici, metoda převede vrácenou DateTime hodnotu z UTC na místní čas a nastaví jeho vlastnost 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 Přestože je tato hodnota platná, je ignorována.Although valid, this value is ignored.
RoundtripKind Pro řetězce, které obsahují informace o časovém pásmu, se snaží zabránit převodu řetězce data a času na hodnotu DateTime, která představuje místní čas s vlastností Kind nastavenou 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. Obvykle je takový řetězec vytvořen voláním metody DateTime.ToString(String) a pomocí specifikátoru standardního formátu "o", "r" nebo "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.

Návratová hodnota a datum a čas. druhThe return value and DateTime.Kind

DateTime.Parse přetížení vrací hodnotu DateTime, jejíž vlastnost Kind obsahuje informace o časovém pásmu.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Může to znamenat, že čas:It can indicate that the time is:

Obecně platí, že metoda Parse vrátí objekt DateTime, jehož vlastnost Kind je DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Nicméně metoda Parse může také provádět převod časového pásma a nastavit hodnotu vlastnosti Kind odlišně v závislosti na hodnotách s a stylesch parametrů: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:

IfIf Převod časového pásmaTime zone conversion Druh – vlastnostKind property
s obsahuje informace o časovém pásmu.s contains time zone information. Datum a čas se převede na čas v místním časovém pásmu.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s obsahuje informace o časovém pásmu a styles obsahuje příznak AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. Datum a čas se převede na koordinovaný světový čas (UTC).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s obsahuje označení časového pásma Z nebo GMT a styles obsahuje příznak RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. Datum a čas jsou interpretovány jako UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

Následující příklad převede řetězce data obsahující informace o časovém pásmu na čas v místním časovém pásmu: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                                             

Pomocí příznaku DateTimeStyles.RoundtripKind můžete také zachovat hodnotu vlastnosti Kind data a času během operace formátování a analýzy.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. Následující příklad ukazuje, jak příznak RoundtripKind ovlivňuje operaci analýzy u DateTime hodnot, které jsou převedeny na řetězce pomocí specifikátoru formátu "o", "r" nebo "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)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí konvencí aktuální jazykové verze vlákna.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

Řetězec, který obsahuje datum a čas k převedení.A string that contains a date and time to convert. Další informace naleznete v řetězci, který chcete analyzovat .See The string to parse for more information.

Návraty

Objekt, který je ekvivalentní data a času obsaženému v s.An object that is equivalent to the date and time contained in s.

Výjimky

s je null.s is null.

s neobsahuje platnou řetězcovou reprezentaci data a času.s does not contain a valid string representation of a date and time.

Poznámky

Pokud s obsahuje informace o časovém pásmu, vrátí tato metoda hodnotu DateTime, jejíž vlastnost Kind je DateTimeKind.Local a převede datum a čas v s na místní čas.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. V opačném případě neprovede žádný převod časového pásma a vrátí hodnotu DateTime, jejíž vlastnost Kind je DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Toto přetížení se pokusí analyzovat s pomocí formátovacích úmluv aktuální jazykové verze.This overload attempts to parse s by using the formatting conventions of the current culture. Aktuální jazyková verze je označena vlastností CurrentCulture.The current culture is indicated by the CurrentCulture property. Chcete-li analyzovat řetězec pomocí formátovacích konvencí konkrétní jazykové verze, zavolejte Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) přetížení.To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Toto přetížení se pokusí analyzovat s pomocí stylu DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

PříkladExample

Následující příklad analyzuje řetězcovou reprezentaci několika hodnot data a času podle:The following example parses the string representation of several date and time values by:

  • Pomocí výchozího poskytovatele formátu, který poskytuje konvence formátování aktuální jazykové verze vlákna počítače použitého k výrobě příkladu výstupu.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. Výstup z tohoto příkladu odráží konvence formátování jazykové verze en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Použití výchozí hodnoty stylu, která je AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Zpracovává výjimku FormatException, která je vyvolána, když se metoda pokusí analyzovat řetězcové vyjádření data a času pomocí některých konvencí formátování jiné jazykové verze.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. Také ukazuje, jak úspěšně analyzovat hodnotu data a času, která nepoužívá konvence formátování aktuální jazykové verze vlákna.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.

Viz také

Parse(String, IFormatProvider)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí informací o formátování specifické pro jazykovou verzi.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

Řetězec, který obsahuje datum a čas k převedení.A string that contains a date and time to convert. Další informace naleznete v řetězci, který chcete analyzovat .See The string to parse for more information.

provider
IFormatProvider

Objekt, který poskytuje informace o formátu specifické jazykové verze o s.An object that supplies culture-specific format information about s. Viz Analýza a kulturní konvenceSee Parsing and cultural conventions

Návraty

Objekt, který je ekvivalentní data a času obsaženému v s určeném parametrem provider.An object that is equivalent to the date and time contained in s as specified by provider.

Výjimky

s je null.s is null.

s neobsahuje platnou řetězcovou reprezentaci data a času.s does not contain a valid string representation of a date and time.

Poznámky

Pokud s obsahuje informace o časovém pásmu, vrátí tato metoda hodnotu DateTime, jejíž vlastnost Kind je DateTimeKind.Local a převede datum a čas v s na místní čas.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. V opačném případě neprovede žádný převod časového pásma a vrátí hodnotu DateTime, jejíž vlastnost Kind je DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Toto přetížení se pokouší analyzovat s pomocí stylu DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

PříkladExample

Následující příklad analyzuje pole řetězců s daty pomocí konvencí pro jazykové verze en-US, fr-FR a de-DE.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Ukazuje, že řetězcové reprezentace jednoho data lze interpretovat odlišně v různých jazykových verzích.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.

Viz také

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Převede rozsah paměti obsahující řetězcovou reprezentaci data a času na jeho DateTime ekvivalent pomocí informací o formátování specifických pro jazykovou verzi a stylu formátování.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 = null, 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>

Rozsah paměti, který obsahuje řetězec k analýze.The memory span that contains the string to parse. Další informace naleznete v řetězci, který chcete analyzovat .See The string to parse for more information.

provider
IFormatProvider

Objekt, který poskytuje informace o formátu specifické jazykové verze o s.An object that supplies culture-specific format information about s. Viz Analýza a kulturní konvenceSee Parsing and cultural conventions

styles
DateTimeStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny v s pro úspěšné provedení operace analýzy a které definují, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu.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. Typická hodnota, která se má zadat, je None.A typical value to specify is None.

Návraty

Objekt, který je ekvivalentní data a času obsaženému v s, jak je uvedeno v provider a styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Výjimky

s neobsahuje platnou řetězcovou reprezentaci data a času.s does not contain a valid string representation of a date and time.

styles obsahuje neplatnou kombinaci hodnot DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Například AssumeLocal i AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles)

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent pomocí informací o formátování specifických pro jazykovou verzi a stylu formátování.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

Řetězec, který obsahuje datum a čas k převedení.A string that contains a date and time to convert. Další informace naleznete v řetězci, který chcete analyzovat .See The string to parse for more information.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s.An object that supplies culture-specific formatting information about s. Viz Analýza a kulturní konvenceSee Parsing and cultural conventions

styles
DateTimeStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny v s pro úspěšné provedení operace analýzy a které definují, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu.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. Typická hodnota, která se má zadat, je None.A typical value to specify is None.

Návraty

Objekt, který je ekvivalentní data a času obsaženému v s, jak je uvedeno v provider a styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Výjimky

s je null.s is null.

s neobsahuje platnou řetězcovou reprezentaci data a času.s does not contain a valid string representation of a date and time.

styles obsahuje neplatnou kombinaci hodnot DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Například AssumeLocal i AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Poznámky

Přetížení této metody převede datum a čas v s a nastaví vlastnost Kind vrácené DateTime hodnoty následujícím způsobem:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

IfIf Převod časového pásmaTime zone conversion Druh – vlastnostKind property
s neobsahují žádné informace o časovém pásmu.s contains no time zone information. ŽádnéNone. DateTimeKind.Unspecified
s obsahuje informace o časovém pásmu.s contains time zone information. Na čas v místním časovém pásmuTo the time in the local time zone DateTimeKind.Local
s obsahuje informace o časovém pásmu a styles obsahuje příznak DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. Na koordinovaný světový čas (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s obsahuje označení časového pásma Z nebo GMT a styles obsahuje DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. ŽádnéNone. DateTimeKind.Utc

PříkladExample

Následující příklad ukazuje metodu Parse(String, IFormatProvider, DateTimeStyles) a zobrazuje hodnotu vlastnosti Kind výsledných DateTimech hodnot.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.

Viz také

Platí pro