DateTime Struktura

Definice

Představuje okamžitý čas, obvykle vyjádřený jako datum a čas dne.

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IConvertible, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable
[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable
type DateTime = struct
    interface IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
Dědičnost
DateTime
Atributy
Implementuje

Poznámky

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.

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.

Tento článek obsahuje několik příkladů, které používají DateTime typ :

Příklady inicializace

Formátování objektů DateTime jako řetězců

Analýza řetězců jako DateTime objektů

DateTime Rozlišení

Jazyková verze a kalendáře

Trvalosti

Tato část obsahuje témata pro mnoho běžných použití DateTime struktury:

Typ hodnoty představuje kalendářní data a časy s hodnotami od DateTime 00:00:00 (půlnoc), 1. ledna 0001 Anno Domini (Common Era) do 23:59:59, 31. prosince 9999 A.D. (C.E.) v gregoriánském kalendáři.

Časové hodnoty se měří ve 100 jednotkách nanosekundových znacích označovaných jako ticky. Konkrétní datum je počet kmitání od 12:00 půlnoci, 1. ledna 0001 A.D. (C.E.) v GregorianCalendar kalendáři. Toto číslo vyloučí značky, které se přičtou přeskočeně v sekundách. Například hodnota značek 31241376000000000L představuje datum pátek 1. ledna 0100 12:00:00 půlnoc. Hodnota DateTime je vždy vyjádřena v kontextu explicitního nebo výchozího kalendáře.

Poznámka

Pokud pracujete s hodnotou značek, kterou chcete převést na nějaký jiný časový interval, například minuty nebo sekundy, měli byste k provedení převodu použít konstantu TimeSpan.TicksPerDay , , , nebo TimeSpan.TicksPerHour TimeSpan.TicksPerMinute TimeSpan.TicksPerSecond TimeSpan.TicksPerMillisecond . Pokud chcete například ke komponentě hodnoty přidat počet sekund vyjádřený zadaným počtem značek, můžete Second DateTime použít výraz dateValue.Second + nTicks/Timespan.TicksPerSecond .

Zdroj pro celou sadu příkladů z tohoto článku můžete zobrazit v jazyce Visual Basic nebo C# z úložiště dokumentace na GitHub.

Poznámka

Alternativou ke DateTime struktuře pro práci s hodnotami data a času v konkrétních časových pásmech je DateTimeOffset struktura. Struktura ukládá informace o datu a čase do privátního pole a počet minut, o které se toto datum a čas liší od standardu UTC v DateTimeOffset DateTime soukromém Int16 poli. Díky tomu může hodnota odrážet čas v konkrétním časovém pásmu, zatímco hodnota může jednoznačně odrážet pouze DateTimeOffset čas UTC a místní časové DateTime pásmo. Diskuzi o tom, kdy použít strukturu nebo strukturu při práci s hodnotami data a času, najdete v tématu Volba mezi DateTime DateTimeOffset DateTime, DateTimeOffset, TimeSpan a TimeZoneInfo.

Inicializace objektu DateTime

Počáteční hodnotu můžete nové hodnotě přiřadit mnoha DateTime různými způsoby:

  • Volání konstruktoru, buď jednoho, kde zadáte argumenty pro hodnoty, nebo použijete implicitní konstruktor bez parametrů.
  • Přiřazení k DateTime návratové hodnotě vlastnosti nebo metody.
  • Parsování DateTime hodnoty z řetězcové reprezentace
  • Vytvoření instance Visual Basic pomocí funkcí jazyka specifických pro konkrétní DateTime jazyk.

Následující fragmenty kódu ukazují příklady každého z nich:

Vyvolání konstruktorů

Zavoláte jakékoli přetížení konstruktoru, které určuje prvky hodnoty data a času (například rok, měsíc a den DateTime nebo počet značek). Následující kód vytvoří konkrétní datum pomocí konstruktoru DateTime určujícího rok, měsíc, den, hodinu, minutu a sekundu.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

Implicitní konstruktor DateTime bez parametrů struktury vyvoláte, když chcete inicializovat na DateTime výchozí hodnotu. (Podrobnosti o implicitním konstruktoru bez parametrů typu hodnoty najdete v tématu Typy hodnot.) Některé kompilátory také podporují deklaraci DateTime hodnoty bez explicitního přiřazení hodnoty. Vytvoření hodnoty bez explicitní inicializace má také za výsledek výchozí hodnotu. Následující příklad ukazuje implicitní konstruktor bez parametrů v jazyce C# a Visual Basic a také deklaraci bez přiřazení v DateTime DateTime Visual Basic.

Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
Přiřazení vypočítané hodnoty

Objektu můžete přiřadit DateTime hodnotu data a času vrácenou vlastností nebo metodou. Následující příklad přiřadí aktuální datum a čas, aktuální datum a čas koordinovaného univerzálního času (UTC) a aktuální datum třem novým DateTime proměnným.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
Analýza řetězce, který představuje DateTime

Všechny Parse metody , , a ParseExact TryParse TryParseExact převádí řetězec na ekvivalentní hodnotu data a času. Následující příklady používají metody Parse ParseExact a k parsování řetězce a jeho převodu na DateTime hodnotu. Druhý formát používá formulář podporovaný standardem ISO 8601 pro reprezentaci data a času ve formátu řetězce. Tato standardní reprezentace se často používá k přenosu informací o datu ve webových službách.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

Metody a označují, zda je řetězec platnou reprezentací hodnoty, a pokud TryParse TryParseExact DateTime je, provádí převod.

Syntaxe pro konkrétní jazyk pro Visual Basic

Následující Visual Basic inicializuje novou DateTime hodnotu.

Dim date1 As Date = #5/1/2008 8:30:52AM#

Hodnoty DateTime a jejich řetězcové vyjádření

Interně se všechny hodnoty reprezentují jako počet kmitů (počet 100nanosekundových intervalů), které uplynuly od DateTime půlnoci ve 12:00:00, 1. ledna 0001. Skutečná DateTime hodnota je nezávislá na způsobu, jakým se tato hodnota zobrazí při zobrazení. Vzhled hodnoty je výsledkem operace formátování, která převede hodnotu DateTime na řetězcovou reprezentaci.

Vzhled hodnot data a času závisí na jazykové verzi, mezinárodních standardech, požadavcích na aplikace a osobních preferencích. Struktura DateTime nabízí flexibilitu při formátování hodnot data a času prostřednictvím přetížení ToString . Výchozí metoda vrátí řetězcové vyjádření hodnoty data a času pomocí vzoru krátkého a dlouhého času aktuální jazykové DateTime.ToString() verze. Následující příklad používá výchozí DateTime.ToString() metodu. Zobrazuje datum a čas pomocí vzoru krátkého data a dlouhého času pro aktuální jazykovou verzi. Jazyková verze en-US je aktuální jazyková verze v počítači, na kterém byl příklad spuštěn.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Možná budete muset formátovat data v konkrétní jazykové verzi, aby podporovala webové scénáře, kde server může být v jiné jazykové verzi než klient. Jazykovou verzi určíte pomocí metody , která vytvoří reprezentaci krátkého DateTime.ToString(IFormatProvider) data a dlouhého času v konkrétní jazykové verzi. Následující příklad používá metodu k zobrazení data a času pomocí vzoru krátkého data a dlouhého času pro jazykovou verzi DateTime.ToString(IFormatProvider) fr-FR.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

Jiné aplikace mohou vyžadovat různá řetězcová vyjádření data. Metoda DateTime.ToString(String) vrátí řetězcovou reprezentaci definovanou specifikátorem standardního nebo vlastního formátu pomocí konvencí formátování aktuální jazykové verze. Následující příklad používá metodu k zobrazení úplného vzoru data a času pro jazykovou verzi en-US, aktuální jazykovou verzi v počítači, na kterém byl DateTime.ToString(String) příklad spuštěn.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Nakonec můžete určit jazykovou verzi i formát pomocí DateTime.ToString(String, IFormatProvider) metody . Následující příklad používá DateTime.ToString(String, IFormatProvider) metodu k zobrazení úplného vzoru data a času pro jazykovou verzi fr-FR.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

Přetížení DateTime.ToString(String) lze také použít s řetězcem vlastního formátu k určení jiných formátů. Následující příklad ukazuje, jak formátovat řetězec pomocí standardního formátu ISO 8601, který se často používá pro webové služby. Formát Iso 8601 nemá odpovídající řetězec standardního formátu.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"));
// Displays 20080301T07:00:00Z
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z

Další informace o formátování hodnot najdete v tématu Standardní řetězce formátu data a času a Vlastní řetězce formátu data DateTime a času.

Analýza hodnot DateTime z řetězců

Analýza převede řetězcové vyjádření data a času na DateTime hodnotu. Řetězce data a času mají obvykle dvě různá použití v aplikacích:

  • Datum a čas mají různé podoby a odrážejí konvence aktuální jazykové verze nebo konkrétní jazykové verze. Aplikace například umožňuje uživateli, jehož aktuální jazyková verze je en-US, zadat hodnotu data jako "15/12/2013" nebo "15. prosince 2013". Umožňuje uživateli, jehož aktuální jazyková verze je en-gb, zadat hodnotu data jako "12. 15. 2013" nebo "15. prosince 2013".

  • Datum a čas je vyjádřeno v předdefinovaném formátu. Aplikace například serializuje datum jako "20130103" nezávisle na jazykové verzi, ve které je aplikace spuštěna. Aplikace může vyžadovat zadání kalendářních dat v krátkém formátu data aktuální jazykové verze.

Pomocí metody nebo převedete řetězec z jednoho z běžných formátů data a času používaných jazykovou Parse TryParse verzí na DateTime hodnotu. Následující příklad ukazuje, jak lze použít k převodu řetězců data v různých formátech specifických pro jazykovou TryParse verzi na DateTime hodnotu. Změní aktuální jazykovou verzi na angličtinu (Velká Británie) a volá metodu , která vygeneruje pole GetDateTimeFormats() řetězců data a času. Potom předá každý prvek v poli TryParse metodě . Výstup z příkladu ukazuje, že metoda analýzy dokázala úspěšně převést každý řetězec data a času specifický pro jazykovou verzi.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    else
        badFormats.Add(dateString);
}

// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
    Console.WriteLine("\nStrings that could not be parsed: ");
    foreach (var badFormat in badFormats)
        Console.WriteLine($"   {badFormat}");
}
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' The example displays the following output:
'       Date String                           Date               
'       
'       01/06/2013                            01/06/2013 00:00:00
'       01/06/13                              01/06/2013 00:00:00
'       1/6/13                                01/06/2013 00:00:00
'       1.6.13                                01/06/2013 00:00:00
'       2013-06-01                            01/06/2013 00:00:00
'       01 June 2013                          01/06/2013 00:00:00
'       1 June 2013                           01/06/2013 00:00:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       01 June                               01/06/2013 00:00:00
'       01 June                               01/06/2013 00:00:00
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       2013-06-01T12:32:30                   01/06/2013 12:32:30
'       12:32                                 22/04/2013 12:32:00
'       12:32                                 22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
'       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
'       June 2013                             01/06/2013 00:00:00
'       June 2013                             01/06/2013 00:00:00

Metody a slouží ParseExact TryParseExact k převodu řetězce, který se musí shodovat s konkrétním formátem nebo formáty na DateTime hodnotu. Jako parametr metody analýzy zadáte jeden nebo více řetězců formátu data a času. Následující příklad používá metodu k převodu řetězců, které musí být buď ve formátu TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) "yyyyMMdd" nebo ve formátu "HHmmss" na DateTime hodnoty.

string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", "  20130816   ",
                   "115216", "521116", "  115216  " };
DateTime parsedDate;

foreach (var dateString in dateStrings)
{
    if (DateTime.TryParseExact(dateString, formats, null,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' The example displays the following output:
'       20130816 --> 8/16/2013 12:00 AM
'       Cannot convert 20131608
'         20130816    --> 8/16/2013 12:00 AM
'       115216 --> 4/22/2013 11:52 AM
'       Cannot convert 521116
'         115216   --> 4/22/2013 11:52 AM

Jedním z běžných použití pro je převod řetězcové reprezentace z webové služby, obvykle ve standardním formátu ParseExact ISO 8601. Následující kód ukazuje správný formátovací řetězec, který se má použít:

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Pokud řetězec nelze analyzovat, metody a Parse ParseExact vyvolá výjimku. Metody TryParse TryParseExact a vrátí Boolean hodnotu, která označuje, jestli byl převod úspěšný nebo neúspěšný. Ve scénářích, kde je výkon TryParse TryParseExact důležitý, byste měli použít metody nebo . Operace analýzy řetězců data a času má tendenci mít vysokou míru selhání a zpracování výjimek je nákladné. Tyto metody použijte, pokud jsou řetězce vstupní od uživatelů nebo pocházející z neznámého zdroje.

Další informace o parsování hodnot data a času najdete v tématu Analýza řetězců data a času.

Hodnoty data a času

Popisy časových hodnot v tomto DateTime typu se často vyjadřují pomocí standardu UTC (Coordinated Universal Time). Koordinovaný univerzální čas (GMT) je mezinárodní uznávaný název gmt (GmT). Koordinovaný univerzální čas je čas měřený na nultých stupních zeměpisné délky, bod původu UTC. Letní čas se na UTC vztahuje.

Místní čas je relativní vzhledem ke konkrétnímu časovému pásmu. Časové pásmo je přidruženo k posunu časového pásma. Posun časového pásma je posunutí časového pásma měřeného v hodinách od bodu původu UTC. Kromě toho je místní čas volitelně ovlivněn letním časem, který sčítá nebo odečítá úpravu časového intervalu. Místní čas se vypočítá tak, že se posun časového pásma přidá do času UTC a v případě potřeby se upraví pro letní čas. Posun časového pásma v bodu původu UTC je nula.

Čas UTC je vhodný pro výpočty, porovnání a ukládání dat a času v souborech. Místní čas je vhodný pro zobrazení v uživatelských rozhraních desktopových aplikací. Aplikace s časovými pásmy (například mnoho webových aplikací) musí také pracovat s řadou dalších časových pásem.

Pokud je vlastnost objektu , není specifikováno, jestli je reprezentovaný čas místní čas, čas UTC nebo čas Kind DateTime v DateTimeKind.Unspecified nějakém jiném časovém pásmu.

Řešení data a času

Poznámka

Jako alternativu k provádění aritmetické operace data a času s hodnotami, které měří uplynulý čas, můžete DateTime použít Stopwatch třídu .

Vlastnost Ticks vyjadřuje hodnoty data a času v jednotkách desetimilonth sekundy. Vlastnost Millisecond vrátí tisícen sekundy v hodnotě data a času. Použití opakovaných volání DateTime.Now vlastnosti k měření uplynulého času závisí na systémových hodinách. Systémové hodiny na Windows 7 a Windows 8 mají rozlišení přibližně 15 milisekund. Toto rozlišení ovlivňuje malé časové intervaly menší než 100 milisekund.

Následující příklad znázorňuje závislost aktuálních hodnot data a času na rozlišení systémových hodin. V tomto příkladu se vnější smyčka opakuje 20krát a vnitřní smyčka slouží ke zpoždění vnější smyčky. Pokud je hodnota čítače vnější smyčky 10, volání metody zavádí Thread.Sleep zpoždění 5 milisekund. Následující příklad ukazuje počet milisekund vrácených vlastností DateTime.Now.Milliseconds se změní až po volání metody Thread.Sleep .

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

Operace data a času

Výpočet pomocí DateTime struktury, jako je Add Subtract nebo , neupravuje hodnotu struktury. Místo toho výpočet vrátí novou DateTime strukturu, jejíž hodnota je výsledkem výpočtu.

Operace převodu mezi časovými pásmy (například mezi (UTC) a místním časem nebo mezi jedním časovým pásmem a jiným) vezměte v úvahu letní čas, ale aritmetické operace a operace porovnání nikoli.

Samotná DateTime struktura nabízí omezenou podporu pro převod z jednoho časového pásma na jiné. Pomocí metody můžete převést UTC na místní čas nebo můžete použít metodu k převodu z místního času ToLocalTime ToUniversalTime na UTC. Ve třídě je však k dispozici úplná sada metod převodu časových TimeZoneInfo pásem. Pomocí těchto metod převedete čas v jakémkoli z časových pásem na čas v jakémkoli jiném časovém pásmu.

Výpočty a porovnání objektů jsou smysluplné pouze v případě, DateTime že objekty představují časy ve stejném časovém pásmu. Objekt můžete použít k reprezentaci časového pásma hodnoty, i když jsou tyto dva volně TimeZoneInfo DateTime svázat. Objekt nemá vlastnost, která vrací objekt, který představuje časové pásmo hodnoty data DateTime a času. Vlastnost Kind určuje, jestli představuje DateTime utc, místní čas nebo není specifikován. V aplikaci s časovými pásmy se při určování časového pásma, ve kterém byl objekt vytvořen, musíte spoléhat na nějaký DateTime externí mechanismus. Můžete použít strukturu, která zabalí hodnotu i objekt, který představuje DateTime TimeZoneInfo časové pásmo DateTime hodnoty. Podrobnosti o použití standardu UTC ve výpočtech a porovnání s hodnotami najdete v tématu Provádění aritmetických operací s DateTime datya časy .

Každý člen implicitně používá k provedení své operace DateTime gregoriánské kalendář. Výjimky jsou metody, které implicitně určují kalendář. Patří mezi ně konstruktory, které určují kalendář, a metody s parametrem odvozeným z IFormatProvider , například System.Globalization.DateTimeFormatInfo .

Operace podle členů typu vezměte v úvahu podrobnosti, jako jsou posouvání a počet DateTime dní v měsíci.

Hodnoty a kalendáře data a času

Knihovna .NET Framework tříd obsahuje řadu tříd kalendáře, z nichž všechny jsou odvozeny z Calendar třídy . Jsou to tyto:

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.

Každá jazyková verze používá výchozí kalendář definovaný vlastností jen pro CultureInfo.Calendar čtení. Každá jazyková verze může podporovat jeden nebo více kalendářů definovaných vlastností jen pro CultureInfo.OptionalCalendars čtení. Kalendář aktuálně používaný konkrétním CultureInfo objektem je definován jeho DateTimeFormatInfo.Calendar vlastností. Musí to být jeden z kalendářů nalezených v CultureInfo.OptionalCalendars poli.

Aktuální kalendář jazykové verze se používá ve všech operacích formátování pro jazykovou verzi. Například výchozí kalendář kultury thajštiny je thajština a éra, který je reprezentován ThaiBuddhistCalendar třídou . Pokud se v operaci formátování data a času použije objekt, který představuje thajštinu, použije se ve výchozím nastavení thajština CultureInfo éra. Gregoriánské kalendář se používá pouze v případě, že se změní vlastnost jazykové DateTimeFormatInfo.Calendar verze, jak ukazuje následující příklad:

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

Aktuální kalendář jazykové verze se také používá ve všech operacích analýzy této jazykové verze, jak ukazuje následující příklad.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Instanci hodnoty vytváříte pomocí prvků data a času (počet roku, měsíce a dne) konkrétního kalendáře zavoláním konstruktoru DateTime, který obsahuje parametr, a předáte mu objekt, který představuje DateTime calendar tento Calendar kalendář. Následující příklad používá prvky data a času z ThaiBuddhistCalendar kalendáře.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime Konstruktory, které nezahrnují parametr, předpokládají, že prvky data a času jsou vyjádřeny jako calendar jednotky v gregoriánském kalendáři.

Všechny ostatní DateTime vlastnosti a metody používají gregoriánské kalendář. Například vlastnost vrátí rok v gregoriánském kalendáři a metoda předpokládá, že parametr je rok v DateTime.Year DateTime.IsLeapYear(Int32) year gregoriánském kalendáři. Každý DateTime člen, který používá gregoriánské kalendář, má odpovídajícího člena Calendar třídy, která používá konkrétní kalendář. Například metoda vrátí rok v konkrétním kalendáři a metoda interpretuje parametr jako číslo roku Calendar.GetYear Calendar.IsLeapYear v konkrétním year kalendáři. Následující příklad používá a DateTime odpovídající členy ThaiBuddhistCalendar třídy.

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

Struktura DateTime obsahuje DayOfWeek vlastnost, která vrací den v týdnu v gregoriánském kalendáři. Nezahrnuje člen, který umožňuje načíst číslo týdne v roce. Pokud chcete načíst týden v roce, zavolejte metodu jednotlivého Calendar.GetWeekOfYear kalendáře. V následujícím příkladu je uvedena ukázka.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

Další informace o datech a kalendářích najdete v tématu Práce s kalendáři.

Zachování hodnot DateTime

Hodnoty můžete DateTime zachovat čtyřmi způsoby:

Je nutné zajistit, aby rutina, která obnovuje hodnoty, neztratil data, nebo vyvolat výjimku bez ohledu DateTime na to, kterou metodu zvolíte. DateTime Hodnoty by měly být round-trip. To znamená, že původní hodnota a obnovená hodnota by měly být stejné. A pokud původní hodnota představuje jeden okamžik času, měla by identifikovat stejný okamžik, kdy se DateTime obnoví.

Zachování hodnot jako řetězců

Pokud chcete úspěšně DateTime obnovit hodnoty, které jsou trvalé jako řetězce, postupujte podle těchto pravidel:

  • Při obnovování řetězce jako při zachování řetězce vytvořte stejné předpoklady týkající se formátování specifického pro jazykovou verzi. Chcete-li zajistit, aby byl řetězec obnoven v systému, jehož aktuální jazyková verze se liší od jazykové verze systému, ve které byl uložen, zavolejte přetížení pro uložení řetězce pomocí konvencí ToString invariantní jazykové verze. Voláním nebo přetížení obnovte řetězec pomocí Parse(String, IFormatProvider, DateTimeStyles) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) konvencí invariantní jazykové verze. Nikdy nepoužívejte ToString() přetížení , nebo , která používají Parse(String) TryParse(String, DateTime) konvence aktuální jazykové verze.

  • Pokud datum představuje jeden okamžik času, ujistěte se, že představuje stejný okamžik v čase, kdy se obnoví, a to i v jiném časovém pásmu. Před DateTime uložením převeďte hodnotu na koordinovaný univerzální čas (UTC). Můžete také serializovat hodnotu spolu s informacemi o časovém pásmu. Další informace o tomto přístupu najdete v tématu Serializace data a času a časového pásma.

Nejběžnější chybou při zachování hodnot jako řetězců je spoléhání na konvence formátování výchozí DateTime nebo aktuální jazykové verze. K problémům dochází v případě, že se při ukládání a obnovování řetězců liší aktuální jazyková verze. Následující příklad ilustruje tyto problémy. Ukládá pět kalendářních dat pomocí konvencí formátování aktuální jazykové verze, což je v tomto případě angličtina (USA). Obnoví data pomocí konvencí formátování jiné jazykové verze, což je v tomto případě angličtina (Velká Británie). Vzhledem k tomu, že se konvence formátování těchto dvou jazykových verzí liší, nelze obnovit dvě kalendářní data a zbývající tři kalendářní data jsou nesprávně interpretována. Pokud také původní hodnoty data a času představují jednotlivé okamžiky v čase, jsou časy obnovení nesprávné, protože se ztratily informace o časovém pásmu.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParse(inputValue, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...
Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       Cannot parse '6/14/2014 6:32:00 AM'
'       '7/10/2014 11:49:00 PM' --> 07 October 2014 23:49
'       '1/10/2015 1:16:00 AM' --> 01 October 2015 01:16
'       Cannot parse '12/20/2014 9:45:00 PM'
'       '6/2/2014 3:14:00 PM' --> 06 February 2014 15:14
'       Restored dates...

Pokud chcete hodnoty DateTime zpátečního připojení úspěšně provést, postupujte takto:

  1. Pokud hodnoty představují jednotlivé momenty času, převeďte je z místního času na čas UTC voláním ToUniversalTime metody .
  2. Převést data na jejich řetězcové reprezentace voláním ToString(String, IFormatProvider) nebo String.Format(IFormatProvider, String, Object[]) přetížení. Použijte konvence formátování invariantní jazykové verze zadáním CultureInfo.InvariantCulture jako provider argumentu. Pomocí standardního formátovacího řetězce "O" nebo "R" určete, že hodnota má být zpáteční.

Pokud chcete obnovit trvalé DateTime hodnoty bez ztráty dat, postupujte následovně:

  1. Parsujte data voláním ParseExact přetížení TryParseExact nebo . Zadejte jako argument a použijte stejný řetězec standardního formátu, který jste CultureInfo.InvariantCulture provider použili format pro argument během převodu. Do DateTimeStyles.RoundtripKind argumentu zahrnte styles hodnotu .
  2. Pokud hodnoty představují jednotlivé okamžiky v čase, zavolejte metodu , která DateTime ToLocalTime převede analyzované datum ze standardu UTC na místní čas.

Následující příklad používá invariantní jazykovou verzi a řetězec standardního formátu "O", aby se zajistilo, že hodnoty uložené a obnovené představují stejný okamžik v čase bez ohledu na systém, jazykovou verzi nebo časové pásmo zdrojového a DateTime cílového systému.

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
                  + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                              DateTimeStyles.RoundtripKind, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{0}'", inputValue);
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
'       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
'       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
'       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
'       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
'       Restored dates...
Zachování hodnot jako celých čísel

Datum a čas můžete zachovat jako Int64 hodnotu, která představuje počet značek. V takovém případě nemusíte uvažovat o jazykové verzi systémů, ve které jsou hodnoty zachovány DateTime a obnoveny.

Zachování hodnoty DateTime jako celého čísla:

  • Pokud hodnoty DateTime představují jednotlivé okamžiky v čase, převeďte je na UTC voláním ToUniversalTime metody .
  • Načte počet značek reprezentovaných DateTime hodnotou z jeho Ticks vlastnosti.

Obnovení DateTime hodnoty, která byla trvale uložena jako celé číslo:

  1. Vytvořte instanci nového DateTime objektu předáním Int64 hodnoty DateTime(Int64) konstruktoru.
  2. Pokud hodnota DateTime představuje jeden okamžik v čase, převeďte ji z UTC na místní čas voláním metody ToLocalTime .

Následující příklad zachová pole hodnot jako celá čísla v systému v americkém DateTime tichomořském časovém pásmu. Obnoví ji v systému v zóně UTC. Soubor obsahující celá čísla obsahuje hodnotu, která označuje celkový počet hodnot, které za ním Int32 Int64 hned následují.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

    bw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, FileMode.Open);
    BinaryReader br = new BinaryReader(fs);
    int items;
    DateTime[] dates;

    try
    {
        items = br.ReadInt32();
        dates = new DateTime[items];

        for (int ctr = 0; ctr < items; ctr++)
        {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
        }
    }
    catch (EndOfStreamException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    catch (IOException)
    {
        Console.WriteLine("Unspecified I/O error. Unable to restore data...");
        return;
    }
    // Thrown during array initialization.
    catch (OutOfMemoryException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    finally
    {
        br.Close();
    }

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       14 June 2014 14:32
'       11 July 2014 07:49
'       10 January 2015 09:16
'       21 December 2014 05:45
'       02 June 2014 23:14
'       Restored dates...

Serializace hodnot DateTime

Hodnoty můžete zachovat prostřednictvím serializace do datového proudu nebo souboru a pak je DateTime obnovit prostřednictvím deserializace. DateTime Data jsou serializována v některém zadaném formátu objektu. Objekty jsou obnoveny při jejich deserializaci. Formátovací modul nebo serializátor, například nebo , zpracovává XmlSerializer BinaryFormatter proces serializace a deserializace. Další informace o serializaci a typy serializace podporované rozhraním .NET Framework naleznete v tématu Serializace.

Následující příklad používá třídu k serializaci a XmlSerializer deserializaci DateTime hodnot. Hodnoty představují všechny rokové dny v 21. století. Výstup představuje výsledek, pokud se příklad spustí v systému, jehož aktuální jazyková verze je Angličtina (Velká Británie). Vzhledem k tomu, že jste deserializaci samotného objektu, kód nemusí zpracovávat kulturní rozdíly ve formátech DateTime data a času.

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[] deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[])serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    foreach (var dat in deserializedDates)
    {
        Console.Write($"   {dat:d}     ");
        nItems++;
        if (nItems % 5 == 0)
            Console.WriteLine();
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096
Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' The example displays the following output:
'    Leap year days from 2000-2100 on an en-GB system:
'       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
'       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
'       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
'       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
'       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

Předchozí příklad neobsahuje informace o čase. Pokud hodnota představuje okamžik v čase a je vyjádřena jako místní čas, převeďte ji z místního času na utc před DateTime serializací voláním ToUniversalTime metody . Po deserializaci ji převeďte z UTC na místní čas voláním ToLocalTime metody . Následující příklad používá třídu k serializaci dat v systému v americkém standardním časovém pásmu Tichomoří BinaryFormatter a k jejich deserializaci v systému v zóně USA – středo DateTime standard.

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        dates[ctr] = dates[ctr].ToUniversalTime();
    }
    bin.Serialize(fs, dates);
    fs.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

    FileStream fs = new FileStream(filenameBin, FileMode.Open);
    BinaryFormatter bin = new BinaryFormatter();
    var dates = (DateTime[])bin.Deserialize(fs);
    fs.Close();

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToLocalTime().ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

Serializace dat Data a časového pásma

Všechny předchozí příklady předpokládaly, DateTime že hodnoty jsou vyjádřeny jako místní časy. Kód převedl hodnoty mezi (UTC) a místním časem tak, aby odrážely stejný okamžik v čase ve zdrojovém a cílovém systému. DateTime Hodnoty mohou také odrážet okamžiky v čase v jiném časovém pásmu než místní a UTC. Vzhledem k tomu, že struktura není časové pásmo, je nutné serializovat hodnotu a objekt, který DateTime DateTime představuje jeho časové TimeZoneInfo pásmo. Vytvořte typ, jehož pole obsahují hodnotu DateTime i její časové pásmo. Následující příklad definuje DateWithTimeZone strukturu.

using System;

namespace DateTimeExtensions
{
    [Serializable]
    public struct DateWithTimeZone
    {
        private TimeZoneInfo tz;
        private DateTime dt;

        public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
        {
            dt = dateValue;
            tz = timeZone ?? TimeZoneInfo.Local;
        }

        public TimeZoneInfo TimeZone
        {
            get { return (tz); }
            set { tz = value; }
        }

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

Důležité

Struktura DateWithTimeZone se používá v následujících dvou příkladech, které serializovat a deserializovat pole DateWithTimeZone objektů. Zdroj pro celou sadu příkladů z tohoto článku můžete zobrazit v jazyce Visual Basic nebo C# z úložiště dokumentace na GitHub.

Pomocí této DateWithTimeZone struktury pak můžete zachovat datum a čas spolu s informacemi o časovém pásmu. Následující příklad používá BinaryFormatter třídu k serializaci pole DateWithTimeZone objektů.

public static void SaveDateWithTimeZone()
{
    DateWithTimeZone[] dates = { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

Následující příklad pak volá BinaryFormatter.Deserialize metodu pro deserializaci.

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

Datum a čas vs. časový interval

Typy DateTime TimeSpan hodnot a se liší v tom, že představují DateTime okamžitý čas, zatímco hodnota TimeSpan představuje časový interval. Můžete odečíst jednu instanci DateTime od jiné, abyste získali TimeSpan objekt, který představuje časový interval mezi nimi. Nebo můžete k aktuálnímu datu přidat kladné hodnoty, abyste TimeSpan DateTime získali DateTime hodnotu, která představuje budoucí datum.

Od objektu můžete přidat nebo odečíst časový DateTime interval. Časové intervaly mohou být záporné nebo kladné a mohou být vyjádřeny v jednotkách, jako jsou intervaly, sekundy nebo TimeSpan jako objekt.

Porovnání rovnosti v rámci tolerance

Porovnání rovnosti hodnot DateTime je přesné. To znamená, že dvě hodnoty musí být vyjádřeny jako stejný počet kmitání, aby byly považovány za stejné. Tato přesnost je často pro mnoho aplikací nepotřebná nebo dokonce nesprávná. Často chcete testovat, jestli se DateTime objekty přibližně rovnají.

Následující příklad ukazuje, jak porovnat zhruba ekvivalentní DateTime hodnoty. Při deklarování rovní se přijímá malý rozdílový okraj.

public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
    long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
    delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
    return Math.Abs(delta) < windowInSeconds;
}

public static void TestRoughlyEquals()
{
    int window = 10;
    int freq = 60 * 60 * 2; // 2 hours;

    DateTime d1 = DateTime.Now;

    DateTime d2 = d1.AddSeconds(2 * window);
    DateTime d3 = d1.AddSeconds(-2 * window);
    DateTime d4 = d1.AddSeconds(window / 2);
    DateTime d5 = d1.AddSeconds(-window / 2);

    DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
    DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
    DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
    DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

    Dim d2 As DateTime = d1.AddSeconds(2 * window)
    Dim d3 As DateTime = d1.AddSeconds(-2 * window)
    Dim d4 As DateTime = d1.AddSeconds(window / 2)
    Dim d5 As DateTime = d1.AddSeconds(-window / 2)

    Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
    Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
    Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
    Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
'    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Hlediska zprostředkovatele komunikace s objekty

Hodnota, která se přenese do aplikace MODELU COM a pak se přenese zpět do spravované aplikace, se říká DateTime round-trip. Hodnota, DateTime která určuje pouze čas, však neukašle, jak byste očekávali.

Pokud zpáteční cestu používáte pouze po dobu, například ve 15:00, je konečným datem a časem 30. prosince 1899. v 15:00 místo ledna, 1 0001, v 15:00 Výchozí .NET Framework modelu COM předpokládají výchozí datum, pokud je zadán pouze čas. Systém MODELU VŠAK předpokládá základní datum 30. prosince 1899, zatímco .NET Framework předpokládá základní datum ledna, 1 0001 c.E.

Pokud je z aplikace předána pouze .NET Framework modelu COM, provádí se speciální zpracování, které převede čas na formát používaný objektem COM. Pokud je z modelu COM předán pouze čas do .NET Framework, není provedeno žádné zvláštní zpracování, protože by to poškodí legitimní data a časy dne nebo před 30. prosincem 1899. Pokud datum začíná svoji zpáteční cestu z modelu COM, .NET Framework a COM zachová datum.

Chování modelu .NET Framework a MODELU COM znamená, že pokud doba platnosti aplikace určuje pouze čas, aplikace musí pamatovat na úpravu nebo ignorování chybného data z DateTime konečného DateTime objektu.

Konstruktory

DateTime(Int32, Int32, Int32)

Inicializuje novou instanci DateTime struktury na zadaný rok, měsíc a den.

DateTime(Int32, Int32, Int32, Calendar)

Inicializuje novou instanci struktury na zadaný rok, měsíc a DateTime den pro zadaný kalendář.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Inicializuje novou instanci struktury na zadaný DateTime rok, měsíc, den, hodinu, minutu a sekundu.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializuje novou instanci struktury pro zadaný rok, měsíc, den, hodinu, minutu a sekundu DateTime pro zadaný kalendář.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializuje novou instanci struktury pro zadaný rok, měsíc, den, hodinu, minutu, sekundu a koordinovaný univerzální čas DateTime (UTC) nebo místní čas.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Inicializuje novou instanci struktury na zadaný DateTime rok, měsíc, den, hodinu, minutu, sekundu a milisekundu.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializuje novou instanci DateTime struktury na zadaný rok, měsíc, den, hodinu, minutu, sekundu a milisekundu pro zadaný kalendář.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Inicializuje novou instanci DateTime struktury na zadaný rok, měsíc, den, hodinu, minutu, sekundu, milisekundu a koordinovaný světový čas (UTC) nebo místní čas pro zadaný kalendář.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializuje novou instanci struktury pro zadaný rok, měsíc, den, hodinu, minutu, sekundu, milisekundu a koordinovaný univerzální čas DateTime (UTC) nebo místní čas.

DateTime(Int64)

Inicializuje novou instanci DateTime struktury na zadaný počet značek.

DateTime(Int64, DateTimeKind)

Inicializuje novou instanci struktury na zadaný počet kmitání a na koordinovaný univerzální čas DateTime (UTC) nebo místní čas.

Pole

MaxValue

Představuje největší možnou hodnotu DateTime . Toto pole je jen ke čtení.

MinValue

Představuje nejmenší možnou hodnotu DateTime . Toto pole je jen ke čtení.

UnixEpoch

Hodnota této konstanty odpovídá 00:00:00.0000000 UTC, 1. ledna 1970, v gregoriánském kalendáři. UnixEpoch definuje bod v čase, kdy se unixový čas rovná 0.

Vlastnosti

Date

Získá komponentu data této instance.

Day

Získá den v měsíci reprezentovaný touto instancí.

DayOfWeek

Získá den v týdnu reprezentovaný touto instancí.

DayOfYear

Získá den roku reprezentovaný touto instancí.

Hour

Získá komponentu hodiny data reprezentované touto instancí.

Kind

Získá hodnotu, která označuje, zda je čas reprezentovaný touto instancí založen na místním čase, koordinovaném univerzálním času (UTC) nebo žádném z těchto možností.

Millisecond

Načte komponentu milisekund data reprezentované touto instancí.

Minute

Získá minutovou komponentu data reprezentované touto instancí.

Month

Získá složku měsíce data reprezentované touto instancí.

Now

Získá objekt, který je nastaven na aktuální datum a čas v tomto počítači DateTime vyjádřený jako místní čas.

Second

Získá komponentu sekund data reprezentované touto instancí.

Ticks

Získá počet tiků, které reprezentují datum a čas této instance.

TimeOfDay

Získá denní dobu této instance.

Today

Získá aktuální datum.

UtcNow

Získá objekt, který je nastaven na aktuální datum a čas v tomto počítači vyjádřený koordinovaným univerzálním DateTime časem (UTC).

Year

Získá složku roku data reprezentované touto instancí.

Metody

Add(TimeSpan)

Vrátí nový DateTime , který přidá hodnotu zadaného TimeSpan do hodnoty této instance.

AddDays(Double)

Vrátí nový DateTime , který přidá zadaný počet dní do hodnoty této instance.

AddHours(Double)

Vrátí nový DateTime , který přidá zadaný počet hodin do hodnoty této instance.

AddMilliseconds(Double)

Vrátí nový DateTime , který přidá zadaný počet milisekund k hodnotě této instance.

AddMinutes(Double)

Vrátí nový DateTime , který přidá zadaný počet minut k hodnotě této instance.

AddMonths(Int32)

Vrátí nový DateTime , který přičte zadaný počet měsíců k hodnotě této instance.

AddSeconds(Double)

Vrátí nový DateTime , který přidá zadaný počet sekund k hodnotě této instance.

AddTicks(Int64)

Vrátí nový DateTime , který přidá zadaný počet tiků k hodnotě této instance.

AddYears(Int32)

Vrátí nový DateTime , který přidá zadaný počet roků k hodnotě této instance.

Compare(DateTime, DateTime)

Porovná dvě instance a vrátí celé číslo, které určuje, zda je první instance dřívější než, stejná jako nebo novější DateTime než druhá instance.

CompareTo(DateTime)

Porovná hodnotu této instance se zadanou hodnotou a vrátí celé číslo, které určuje, zda je tato instance starší než, stejná jako nebo novější než DateTime zadaná DateTime hodnota.

CompareTo(Object)

Porovná hodnotu této instance se zadaným objektem, který obsahuje zadanou hodnotu, a vrátí celé číslo, které určuje, zda je tato instance starší než, stejná jako nebo novější než DateTime zadaná DateTime hodnota.

DaysInMonth(Int32, Int32)

Vrátí počet dní v zadaném měsíci a roce.

Equals(DateTime)

Vrátí hodnotu, která označuje, zda je hodnota této instance rovna hodnotě zadané DateTime instance.

Equals(DateTime, DateTime)

Vrátí hodnotu, která označuje, zda dvě DateTime instance mají stejnou hodnotu data a času.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

FromBinary(Int64)

Deserializace 64 binární hodnoty a znovu vytvoří původní serializovaný DateTime objekt.

FromFileTime(Int64)

převede zadaný čas souboru Windows na ekvivalentní místní čas.

FromFileTimeUtc(Int64)

převede zadaný čas souboru Windows na ekvivalentní čas UTC.

FromOADate(Double)

Vrátí DateTime ekvivalent zadaného data automatizace OLE.

GetDateTimeFormats()

Převede hodnotu této instance na všechny řetězcové reprezentace podporované specifikátory standardního formátu data a času.

GetDateTimeFormats(Char)

Převede hodnotu této instance na všechny řetězcové reprezentace podporované zadaným specifikátorem standardního formátu data a času.

GetDateTimeFormats(Char, IFormatProvider)

Převede hodnotu této instance na všechny řetězcové reprezentace podporované zadaným standardním specifikátorem formátu data a času a informace o formátování specifické pro jazykovou verzi.

GetDateTimeFormats(IFormatProvider)

Převede hodnotu této instance na všechny řetězcové reprezentace podporované specifikátory standardního formátu data a času a zadané informace o formátování specifické pro jazykovou verzi.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetTypeCode()

Vrátí TypeCode hodnotu pro typ hodnoty DateTime .

IsDaylightSavingTime()

Určuje, zda je tato instance DateTime v rozmezí letního času pro aktuální časové pásmo.

IsLeapYear(Int32)

Vrátí údaj, zda je zadaný rok přestupný rok.

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)

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

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Převede určený rozsah reprezentace data a času na jeho DateTime ekvivalent pomocí zadaného formátu, jazykové informace specifické pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu nebo je vyvolána výjimka.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Převede určený rozsah reprezentace data a času na jeho DateTime ekvivalent pomocí zadaného pole formátů, informací o formátu specifické jazykové verze a stylu. Formát řetězcového vyjádření musí přesně odpovídat alespoň jednomu z určených formátů nebo je vyvolána výjimka.

ParseExact(String, String, IFormatProvider)

Převede určenou řetězcovou reprezentaci data a času na svůj DateTime ekvivalent pomocí zadaného formátu a informací o formátu specifické jazykové verze. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Převede určenou řetězcovou reprezentaci data a času na svůj DateTime ekvivalent pomocí zadaného formátu, jazykové informace specifické pro jazykovou verzi a stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu nebo je vyvolána výjimka.

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Převede zadané řetězcové vyjádření data a času na jeho ekvivalent pomocí zadaného pole formátů, informací o formátu specifického pro jazykovou verzi a DateTime stylu. Formát řetězcové reprezentace musí odpovídat alespoň jednomu ze zadaných formátů přesně nebo je vyvolána výjimka.

SpecifyKind(DateTime, DateTimeKind)

Vytvoří nový DateTime objekt, který má stejný počet tiků jako zadaný DateTime , ale je určený buď místní čas, koordinovaný světový čas (UTC), nebo ani jeden, jak je určeno zadanou DateTimeKind hodnotou.

Subtract(DateTime)

Vrátí nový TimeSpan , který odečte zadané datum a čas z hodnoty této instance.

Subtract(TimeSpan)

Vrátí nový DateTime , který odečte zadanou dobu od hodnoty této instance.

ToBinary()

Zaserializace aktuálního DateTime objektu na 64 binární hodnotu, kterou lze následně použít k opětovnému vytvoření DateTime objektu.

ToFileTime()

převede hodnotu aktuálního DateTime objektu na čas Windows souboru.

ToFileTimeUtc()

převede hodnotu aktuálního DateTime objektu na čas Windows souboru.

ToLocalTime()

Převede hodnotu aktuálního DateTime objektu na místní čas.

ToLongDateString()

Převede hodnotu aktuálního DateTime objektu na jeho ekvivalentní řetězcové vyjádření dlouhého data.

ToLongTimeString()

Převede hodnotu aktuálního DateTime objektu na jeho ekvivalent dlouhé řetězcové vyjádření.

ToOADate()

Převede hodnotu této instance na ekvivalentní datum automatizace OLE.

ToShortDateString()

Převede hodnotu aktuálního DateTime objektu na jeho ekvivalentní řetězcové vyjádření krátkého data.

ToShortTimeString()

Převede hodnotu aktuálního DateTime objektu na odpovídající řetězcovou reprezentaci krátkého času.

ToString()

Převede hodnotu aktuálního DateTime objektu na odpovídající řetězcovou reprezentaci pomocí formátovacích úmluv aktuální jazykové verze.

ToString(IFormatProvider)

Převede hodnotu aktuálního DateTime objektu na odpovídající řetězcovou reprezentaci pomocí zadaných informací o formátu specifické jazykové verze.

ToString(String)

Převede hodnotu aktuálního objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu a konvencí DateTime formátování aktuální jazykové verze.

ToString(String, IFormatProvider)

Převede hodnotu aktuálního objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu a informací o formátu DateTime specifickém pro jazykovou verzi.

ToUniversalTime()

Převede hodnotu aktuálního objektu na koordinovaný univerzální DateTime čas (UTC).

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Pokusí se naformátovat hodnotu aktuální instance datetime do poskytnutého rozsahu znaků.

TryParse(ReadOnlySpan<Char>, DateTime)

Převede zadaný rozsah znaků data a času na jeho ekvivalent a vrátí hodnotu, která určuje, zda DateTime byl převod úspěšný.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Převede reprezentaci span data a času na jeho ekvivalent pomocí zadaných informací o formátu specifické pro jazykovou verzi a stylu formátování a vrátí hodnotu, která určuje, zda byl převod DateTime úspěšný.

TryParse(String, DateTime)

Převede zadané řetězcové vyjádření data a času na jeho ekvivalent a vrátí hodnotu, která určuje, zda DateTime byl převod úspěšný.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Převede zadané řetězcové vyjádření data a času na jeho ekvivalent pomocí zadaných informací o formátu specifické pro jazykovou verzi a stylu formátování a vrátí hodnotu, která určuje, zda byl převod DateTime úspěšný.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Převede zadanou reprezentaci span data a času na jeho ekvivalent pomocí zadaného formátu, informací o formátu specifického pro jazykovou verzi a DateTime stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

Převede zadaný rozsah znaků data a času na jeho ekvivalent a vrátí hodnotu, která určuje, zda DateTime byl převod úspěšný.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Převede zadané řetězcové vyjádření data a času na jeho ekvivalent pomocí zadaného formátu, informací o formátu specifického pro jazykovou verzi a DateTime stylu. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Převede zadané řetězcové vyjádření data a času na jeho ekvivalent pomocí zadaného pole formátů, informací o formátu specifického pro jazykovou verzi a DateTime stylu. Formát řetězcové reprezentace musí přesně odpovídat alespoň jednomu ze zadaných formátů. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Operátory

Addition(DateTime, TimeSpan)

Přidá zadaný časový interval k zadanému datu a času a výsledkem je nové datum a čas.

Equality(DateTime, DateTime)

Určuje, zda jsou obě zadané instance objektu DateTime stejné.

GreaterThan(DateTime, DateTime)

Určuje, jestli je zadaný DateTime parametr novější než jiný zadaný parametr DateTime .

GreaterThanOrEqual(DateTime, DateTime)

Určuje, jestli zadaný parametr představuje datum a čas, které je stejné jako nebo DateTime novější než jiné zadané DateTime .

Inequality(DateTime, DateTime)

Určuje, jestli jsou dvě zadané instance objektu DateTime odlišné.

LessThan(DateTime, DateTime)

Určuje, jestli je zadaný DateTime parametr starší než jiný zadaný parametr DateTime .

LessThanOrEqual(DateTime, DateTime)

Určuje, jestli zadaný parametr představuje datum a čas, který je stejný jako nebo DateTime dřívější než jiný zadaný parametr DateTime .

Subtraction(DateTime, DateTime)

Odečte zadané datum a čas od jiného zadaného data a času a vrátí časový interval.

Subtraction(DateTime, TimeSpan)

Odečte zadaný časový interval od zadaného data a času a vrátí nové datum a čas.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.

IConvertible.GetTypeCode()

Vrátí TypeCode pro tuto instanci .

IConvertible.ToBoolean(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToByte(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToChar(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToDateTime(IFormatProvider)

Vrátí aktuální DateTime objekt.

IConvertible.ToDecimal(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToDouble(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToInt16(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToInt32(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToInt64(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToSByte(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToSingle(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToType(Type, IFormatProvider)

Převede aktuální DateTime objekt na objekt zadaného typu.

IConvertible.ToUInt16(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToUInt32(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

IConvertible.ToUInt64(IFormatProvider)

Tento převod není podporován. Při pokusu o použití této metody se vyvolá InvalidCastException .

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Naplní objekt SerializationInfo daty potřebnými k serializaci aktuálního DateTime objektu.

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také