DateTime.Parse Metoda

Definice

Převede řetězcové vyjádření data a času na jeho DateTime ekvivalent.

Přetížení

Parse(String)

Převede řetězcové vyjádření data a času na jeho ekvivalent pomocí DateTime konvencí aktuální jazykové verze.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření data a času na jeho ekvivalent pomocí informací o formátu DateTime specifickém pro jazykovou verzi.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Převede rozsah paměti, který obsahuje řetězcovou reprezentaci data a času, na jeho ekvivalent pomocí informací o formátu specifického pro jazykovou verzi DateTime a stylu formátování.

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

Příklady

Řada příkladů, které volají metodu , je promíchána v části Poznámky tohoto článku a v dokumentaci k DateTime.Parse jednotlivým DateTime.Parse přetížením.

Poznámka

Některé příklady C# v tomto článku se spouštějí v Try.NET inline Code Runner a playground. Kliknutím na tlačítko Spustit spustíte příklad v interaktivním okně. Po spuštění kódu ho můžete upravit a spustit upravený kód tak, že znovu vyberete Spustit . Upravený kód buď běží v interaktivním okně, nebo, pokud kompilace není úspěšná, interaktivní okno zobrazí všechny chybové zprávy kompilátoru C#.

Místní časové pásmo Try.NET inline Code Runner a Playground je KOORDINOVANÝ světový čas nebo UTC. To může mít vliv na chování a výstup příkladů, které ilustrují DateTime typy, a DateTimeOffset TimeZoneInfo a jejich členy.

Můžete si také stáhnout kompletní sadu DateTime.Parse příkladů, které jsou součástí projektu .NET Core pro jazyk C#.

Poznámky

V této části:

Jakou metodu mám volat?

Záměr Call
Parsování řetězce data a času pomocí konvencí aktuální jazykové verze Parse(String) Přetížení
Parsování řetězce data a času pomocí konvencí konkrétní jazykové verze Parse(String, IFormatProvider) přetížení (viz Parsing and Cultural Conventions)
Parsování řetězce data a času pomocí speciálních prvků stylu (například prázdných znaků nebo bez prázdných znaků) Parse(String, IFormatProvider, DateTimeStyles) Přetížení
Parsování řetězce data a času, který musí být v určitém formátu DateTime.ParseExact nebo DateTime.TryParseExact
Parsování řetězce data a času a převod na utc nebo místní čas Parse(String, IFormatProvider, DateTimeStyles) Přetížení
Parsování řetězce data a času bez zpracování výjimek Metoda DateTime.TryParse
Obnovte (zpáteční) hodnotu data a času vytvořenou operací formátování. Předejte metodě řetězec standardního formátu "o" nebo "r" a ToString(String) zavolejte Parse(String, IFormatProvider, DateTimeStyles) přetížení pomocí . DateTimeStyles.RoundtripKind
Parsování řetězce data a času v pevně stanoveném formátu napříč hranicemi počítače (a možná i kulturními) hranicemi DateTime.ParseExact nebo DateTime.TryParseExact – metoda

Řetězec určený k analýze

Metoda Parse se pokusí převést řetězcové vyjádření hodnoty data a času na její DateTime ekvivalent. Pokusí se zcela parsovat vstupní řetězec bez vyvolání FormatException výjimky.

Důležité

Pokud operace analýzy selže kvůli nerozpoznané řetězcové formátu, metoda vyvolá Parse , zatímco metoda vrátí FormatException TryParse false . Vzhledem k tomu, že zpracování výjimek může být nákladné, měli byste použít , pokud se očekává, že operace analýzy bude úspěšná, protože vstupní Parse zdroj je důvěryhodný. TryParse je vhodnější, pokud je pravděpodobnost selhání analýzy pravděpodobná, zejména proto, že vstupní zdroj není důvěryhodný nebo máte rozumné výchozí hodnoty, které byste měli nahradit řetězci, které se úspěšně parsují.

Řetězec, který se má analyzovat, může mít libovolnou z následujících forem:

  • Řetězec s komponentou data a času.

  • Řetězec se součástí data, ale bez času. Pokud komponenta času chybí, předpokládá metoda půlnoc ve 12:00. Pokud má komponenta date dvouciferný rok, převede se na rok na základě 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 argumentem, který nemá hodnotu Calendar.TwoDigitYearMax provider null).

  • Řetězec s komponentou data, která obsahuje pouze složku měsíce a roku, ale bez dne. Metoda předpokládá první den v měsíci.

  • Řetězec s komponentou data, která obsahuje pouze složku měsíce a dne, ale bez roku. Metoda předpokládá aktuální rok.

  • Řetězec s časem, ale bez komponenty data. Metoda předpokládá aktuální datum, pokud nevoláte přetížení a nezahrníte do argumentu . V takovém případě metoda předpokládá datum Parse(String, IFormatProvider, DateTimeStyles) DateTimeStyles.NoCurrentDateDefault styles 1. ledna 0001.

  • Řetězec s časovou komponentou, která zahrnuje pouze hodinu a návrháře dop./odp. bez komponenty data. Metoda předpokládá aktuální datum a čas bez minut a bez sekund. Toto chování můžete změnit voláním přetížení a zahrnutím do argumentu . V takovém případě metoda předpokládá datum Parse(String, IFormatProvider, DateTimeStyles) DateTimeStyles.NoCurrentDateDefault styles 1. ledna 0001.

  • Řetězec, který obsahuje informace o časovém pásmu a vyhovuje standardu ISO 8601. V následujících příkladech první řetězec určuje koordinovaný univerzální čas (UTC) a druhý určuje čas v časovém pásmu, které je o sedm hodin starší než UTC:

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

  • Řetězec, který obsahuje specifikátor GMT a odpovídá formátu času RFC 1123. například:

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

  • Řetězec, který obsahuje datum a čas spolu s informacemi o posunu časového pásma. například:

    "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í konvencí formátování aktuální jazykové verze, což je v tomto případě jazyková verze en-US:

using System;

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

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

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

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 posouvání v kalendářním roce použitém parsovací metodou (viz Parsovánía kulturní konvence), metoda řetězec úspěšně Parse analyzuje. Pokud vstupní řetězec představuje posouvácí den v nesměšném roce, metoda vyvolá FormatException .

Vzhledem k tomu, že se metoda pokusí parsovat řetězcovou reprezentaci data a času pomocí pravidel formátování aktuální nebo zadané jazykové verze, může pokus o parsování řetězce napříč různými jazykovou verzí Parse selhat. Pokud chcete analyzovat konkrétní formát data a času napříč různými národní prostředími, použijte jedno z přetížení metody DateTime.ParseExact a zadejte specifikátor formátu.

Analýzy a kulturní konvence

Všechna přetížení metody jsou citlivá na jazykovou verzi, pokud řetězec, který se má analyzovat (který je reprezentován v následující tabulce), neodpovídá vzoru Parse s ISO 8601. Operace analýzy používá informace o formátování v DateTimeFormatInfo objektu, který je odvozen následujícím způsobem:

Důležité

Éra v japonském kalendáři jsou založená na tom, jak zavládá, a proto se očekává, že se změní. Například 1. května 2019 bylo označeno začátek éry remu v a JapaneseCalendar JapaneseLunisolarCalendar . Taková změna éry ovlivní všechny aplikace, které tyto kalendáře používají. Další informace a informace o tom, zda jsou ovlivněny vaše aplikace, najdete v tématu Zpracování nové éry v japonském kalendáři v rozhraní .NET. Informace o testování aplikací v systémech Windows, abyste zajistili jejich připravenost na změnu období, najdete v tématu Příprava aplikace na změnu v japonském období. Funkce v .NET, které podporují kalendáře s více érami, a osvědčené postupy při práci s kalendáři, které podporují více ér, najdete v tématu Práce s obdobími.

Pokud zavoláte A provider je Informace o formátování jsou odvozeny z
Parse(String) - Aktuální jazyková verze ( DateTimeFormatInfo.CurrentInfo vlastnost)
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) Objekt DateTimeFormatInfo Zadaný DateTimeFormatInfo objekt
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) null Aktuální jazyková verze ( DateTimeFormatInfo.CurrentInfo vlastnost)
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) Objekt CultureInfo Vlastnost CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) nebo Parse(String, IFormatProvider, DateTimeStyles) Vlastní IFormatProvider implementace Metoda IFormatProvider.GetFormat

Při formátování informací odvozených z objektu definuje vlastnost kalendář použitý DateTimeFormatInfo DateTimeFormatInfo.Calendar v operaci analýzy.

Pokud analyzujete řetězec data a času pomocí objektu s vlastním nastavením, které se liší od standardní jazykové verze, vylepšete pravděpodobnost úspěšného převodu pomocí metody místo DateTimeFormatInfo ParseExact metody Parse . Nestandardní řetězec data a času může být složitý a obtížně parsován. Metoda Parse se pokusí parsovat řetězec s několika implicitními vzory analýzy, z nichž všechny můžou selhat. Naproti tomu metoda vyžaduje, abyste explicitně určili jeden nebo více přesných vzorů analýzy, ParseExact které budou pravděpodobně úspěšné. Další informace najdete v části DateTimeFormatInfo a Dynamic Data v DateTimeFormatInfo tématu .

Důležité

Všimněte si, že konvence formátování pro konkrétní jazykovou verzi jsou dynamické a mohou se změnit. To znamená, že analýza operací, které závisí na konvencích formátování výchozí (aktuální) jazykové verze nebo které určují objekt, který představuje jinou jazykovou verzi, než je invariantní jazyková verze, může neočekávaně selhat, pokud dojde k nějaké z IFormatProvider následujících událostí:

  • Data specifická pro jazykovou verzi se změnila mezi hlavními nebo podverzami .NET Framework nebo v důsledku aktualizace stávající verze .NET Framework.
  • Data specifická pro jazykovou verzi odrážejí uživatelské předvolby, které se můžou lišit od počítače k počítači nebo relace k relaci.
  • Data specifická pro jazykovou verzi představují náhradní jazykovou verzi, která přepisuje nastavení standardní jazykové verze nebo vlastní jazykové verze.

Pokud chcete zabránit potížím s parsací dat a časových řetězců spojených se změnami v kulturním datu, můžete analyzovat řetězce data a času pomocí invariantní jazykové verze nebo můžete zavolat metodu nebo a určit přesný formát řetězce, který ParseExact TryParseExact se má analyzovat. Pokud serializujete a deserializovat data data a času, můžete buď použít konvence formátování neutrální jazykové verze, nebo můžete serializovat a deserializovat hodnotu v DateTime binárním formátu.

Další informace najdete v části "Dynamická data jazykové verze" v tématu a v části CultureInfo Zachování hodnot DateTime v DateTime tématu .

Analýza a elementy stylu

Všechna přetížení ignorují úvodní, vnitřní nebo koncové prázdné znaky ve vstupním řetězci (který je Parse reprezentován v následující s tabulce). Datum a čas mohou být v závorkách párem počátečních a koncových znaků ZNAMÉNKA ČÍSLA ("#", U+0023) a mohou být koncové s jedním nebo více znaky NULL (U+0000).

Kromě toho má Parse(String, IFormatProvider, DateTimeStyles) přetížení styles parametr, který se skládá z jednoho nebo více členů DateTimeStyles výčtu. Tento parametr definuje, jak se má interpretovat a jak by se operace s analýzy měla převést s na datum a čas. Následující tabulka popisuje účinek každého DateTimeStyles členu na operaci parsování.

Člen DateTimeStyles Vliv na převod
AdjustToUniversal Parsuje a v případě s potřeby ho převede na UTC následujícím způsobem:

– Pokud zahrnuje posun časového pásma nebo pokud neobsahuje žádné informace o časovém pásmu, ale obsahuje příznak , metoda analyzuje řetězec, volá pro převod vrácené hodnoty na UTC a nastaví s s vlastnost na styles AssumeLocal ToUniversalTime DateTime Kind DateTimeKind.Utc .
– Pokud tato hodnota značí, že představuje UTC, nebo pokud neobsahuje informace o časovém pásmu, ale obsahuje příznak , metoda řetězec s s styles AssumeUniversal parsuje, DateTime Kind neprovádí u vrácené hodnoty žádný převod časového pásma a nastaví vlastnost na DateTimeKind.Utc .
– Ve všech ostatních případech nemá příznak žádný vliv.
AllowInnerWhite Tato hodnota je ignorována. Vnitřní prázdné znaky jsou vždy povoleny v prvcích data a času v s .
AllowLeadingWhite Tato hodnota je ignorována. Počáteční prázdné znaky jsou vždy povoleny v prvcích data a času v s .
AllowTrailingWhite Tato hodnota je ignorována. Koncové prázdné znaky jsou vždy povoleny v prvcích data a času v s .
AllowWhiteSpaces Určuje, které mohou obsahovat úvodní, vnitřní a s koncové prázdné znaky. Toto je výchozí chování. Nelze ji přepsat poskytnutím restriktivnější hodnoty DateTimeStyles výčtu, jako je None .
AssumeLocal Určuje, že pokud s chybí nějaké informace o časovém pásmu, předpokládá se místní čas. Pokud AdjustToUniversal příznak není k dispozici, vlastnost vrácené hodnoty je Kind DateTime nastavena na DateTimeKind.Local .
AssumeUniversal Určuje, že pokud s chybí nějaké informace o časovém pásmu, předpokládá se UTC. Pokud příznak není k dispozici, metoda převede vrácenou hodnotu z UTC na místní čas a AdjustToUniversal nastaví její vlastnost na DateTime Kind DateTimeKind.Local .
None Přestože je tato hodnota platná, je ignorována.
RoundtripKind U řetězců, které obsahují informace o časovém pásmu, se pokusí zabránit převodu řetězce data a času na hodnotu, která představuje místní čas s vlastností DateTime Kind nastavenou na DateTimeKind.Local . Obvykle se takový řetězec vytvoří voláním metody a pomocí specifikátoru standardního formátu DateTime.ToString(String) "o", "r" nebo "u".

Návratová hodnota a DateTime.Kind

Přetížení DateTime.Parse vrátí hodnotu, DateTime jejíž vlastnost obsahuje informace Kind o časovém pásmu. Může to značit, že čas je následující:

Obecně platí, Parse že metoda vrací DateTime objekt, jehož vlastnost je Kind DateTimeKind.Unspecified . Metoda však může také provést převod časového pásma a nastavit hodnotu vlastnosti odlišně v závislosti na hodnotách Parse Kind parametrů a s styles :

Pokud uživatel Převod časového pásma Kind – vlastnost
s obsahuje informace o časovém pásmu. Datum a čas se převedou na čas v místním časovém pásmu. DateTimeKind.Local
s obsahuje informace o časovém pásmu styles a zahrnuje AdjustToUniversal příznak . Datum a čas se převedou na koordinovaný univerzální čas (UTC). DateTimeKind.Utc
s obsahuje označení časového pásma Z nebo GMT a styles zahrnuje příznak RoundtripKind . Datum a čas se interpretují jako UTC. DateTimeKind.Utc

Následující příklad převede řetězce dat, které obsahují informace o časovém pásmu, na čas v místním časovém pásmu:

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

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

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

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
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 ekvivalent pomocí DateTime konvencí aktuální jazykové verze.

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í. Další informace najdete v tématu Řetězec, který se má parsovat.

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v s .

Výjimky

s neobsahuje platné řetězcové vyjádření data a času.

Příklady

Následující příklad analyzuje řetězcovou reprezentaci několika hodnot data a času:

  • Použití výchozího poskytovatele formátu, který poskytuje konvence formátování aktuální jazykové verze počítače použitého k vytvoření příkladu výstupu. Výstup z tohoto příkladu odráží konvence formátování jazykové verze en-US.

  • Použití výchozí hodnoty stylu, což je AllowWhiteSpaces .

Zpracovává výjimku, která je vyvolána, když se metoda pokusí parsovat řetězcové vyjádření data a času pomocí jiných konvencí formátování jazykové FormatException verze. Také ukazuje, jak úspěšně parsovat hodnotu data a času, která nevyu používá konvence formátování aktuální jazykové verze.

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.

Poznámky

Pokud s obsahuje informace o časovém pásmu, vrátí tato metoda hodnotu, jejíž vlastnost je a převede datum a čas v na místní DateTime Kind DateTimeKind.Local s čas. V opačném případě nebude provádět převod časového pásma a vrátí DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Unspecified .

Toto přetížení se pokusí s parsovat pomocí konvencí formátování aktuální jazykové verze. Aktuální jazyková verze je označena CurrentCulture vlastností . Chcete-li analyzovat řetězec pomocí konvencí formátování konkrétní jazykové verze, zavolejte nebo Parse(String, IFormatProvider) Parse(String, IFormatProvider, DateTimeStyles) přetížení.

Toto přetížení se pokusí s parsovat pomocí DateTimeStyles.AllowWhiteSpaces style.

Viz také

Platí pro

Parse(String, IFormatProvider)

Převede řetězcové vyjádření data a času na jeho ekvivalent pomocí informací o formátu DateTime specifickém pro jazykovou verzi.

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

Parametry

s
String

Řetězec, který obsahuje datum a čas k převedení. Další informace najdete v tématu Řetězec, který se má parsovat.

provider
IFormatProvider

Objekt, který poskytuje informace o formátu specifické pro jazykovou s verzi. Viz Analýza a kulturní konvence.

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému s v , jak je určeno parametrem provider .

Výjimky

s neobsahuje platné řetězcové vyjádření data a času.

Příklady

Následující příklad analyzuje pole řetězců data pomocí konvencí jazykových verzí en-US, fr-FR a de-DE. Ukazuje, že řetězcová vyjádření jednoho data lze interpretovat různě v různých kulturách.

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.

Poznámky

Pokud s obsahuje informace o časovém pásmu, vrátí tato metoda hodnotu, jejíž vlastnost je a převede datum a čas v na místní DateTime Kind DateTimeKind.Local s čas. V opačném případě nebude provádět převod časového pásma a vrátí DateTime hodnotu, jejíž Kind vlastnost je DateTimeKind.Unspecified .

Toto přetížení se pokusí s parsovat pomocí DateTimeStyles.AllowWhiteSpaces stylu .

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Převede rozsah paměti, který obsahuje řetězcovou reprezentaci data a času, na jeho ekvivalent pomocí informací o formátu specifického pro jazykovou verzi DateTime a stylu formátování.

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

Parametry

s
ReadOnlySpan<Char>

Rozsah paměti, který obsahuje řetězec k analýze. Další informace najdete v tématu Řetězec, který se má parsovat.

provider
IFormatProvider

Objekt, který poskytuje informace o formátu specifické pro jazykovou s verzi. Viz Analýza a kulturní konvence.

styles
DateTimeStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v pro úspěšné operace analýzy a která definuje, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo s aktuálnímu datu. Typická hodnota, která se má zadat, je None .

Návraty

DateTime

Objekt, který je ekvivalentní datu a času obsaženému v , jak je určeno v a s provider styles .

Výjimky

s neobsahuje platnou řetězcovou reprezentaci data a času.

styles obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například obojí AssumeLocal a AssumeUniversal .

Platí pro

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

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

Parametry

s
String

Řetězec, který obsahuje datum a čas k převedení. Další informace naleznete v řetězci, který chcete analyzovat .

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi s . Viz Analýza a kulturní konvence

styles
DateTimeStyles

Bitová kombinace hodnot výčtu, která určuje prvky stylu, které mohou být přítomny s , aby operace analýzy uspěla a definovala, jak interpretovat analyzované datum ve vztahu k aktuálnímu časovému pásmu nebo aktuálnímu datu. Typická hodnota, která se má zadat None , je.

Návraty

DateTime

Objekt, který je ekvivalentní data a času obsaženému v s , jak je uvedeno v provider a styles .

Výjimky

s neobsahuje platnou řetězcovou reprezentaci data a času.

styles obsahuje neplatnou kombinaci DateTimeStyles hodnot. Například obojí AssumeLocal a AssumeUniversal .

Příklady

Následující příklad ukazuje Parse(String, IFormatProvider, DateTimeStyles) metodu a zobrazuje hodnotu Kind vlastnosti výsledných DateTime hodnot.

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.

Poznámky

Přetížení této metody převede datum a čas v s a nastaví Kind vlastnost vrácené DateTime hodnoty následujícím způsobem:

Pokud uživatel Převod časového pásma Druh – vlastnost
s neobsahuje žádné informace o časovém pásmu. Žádné DateTimeKind.Unspecified
s obsahuje informace o časovém pásmu. Na čas v místním časovém pásmu DateTimeKind.Local
s obsahuje informace o časovém pásmu a styles obsahuje DateTimeStyles.AdjustToUniversal příznak. Na koordinovaný světový čas (UTC) DateTimeKind.Utc
s obsahuje označení časového pásma Z nebo GMT a styles obsahuje DateTimeStyles.RoundtripKind . Žádné DateTimeKind.Utc

Viz také

Platí pro