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í 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ář, který aktuálně používá určitý CultureInfo objekt, 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 tuto jazykovou verzi. Například výchozí kalendář thajské jazykové verze je thajský kalendář období, který je reprezentován ThaiBuddhistCalendar třídou. Pokud CultureInfo je v operaci formátování data a času použit objekt, který představuje jazykovou verzi thajského buddhistickýho kalendáře, je ve výchozím nastavení použit kalendář pro thajský buddhistický období. Gregoriánský kalendář je použit pouze v případě DateTimeFormatInfo.Calendar , že je změněna vlastnost jazykové 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 používá také ve všech operacích analýzy pro tuto jazykovou verzi, 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

Vytvořte instanci DateTime hodnoty pomocí prvků data a času (číslo roku, měsíce a dne) konkrétního kalendáře voláním konstruktoru DateTime , který obsahuje calendar parametr a předáním Calendar objektu, který představuje tento kalendář. V následujícím příkladu jsou použity 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é neobsahují calendar parametr, předpokládají, že prvky data a času jsou vyjádřeny jako jednotky v gregoriánském kalendáři.

Všechny ostatní DateTime vlastnosti a metody používají gregoriánský kalendář. DateTime.YearVlastnost například vrátí rok v gregoriánském kalendáři a DateTime.IsLeapYear(Int32) metoda předpokládá, že year parametr je rok v 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 Calendar.GetYear Metoda vrátí rok v konkrétním kalendáři a Calendar.IsLeapYear metoda interpretuje year parametr jako číslo roku v konkrétním kalendáři. Následující příklad používá DateTime a 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

DateTimeStruktura obsahuje DayOfWeek vlastnost, která vrátí den v týdnu v gregoriánském kalendáři. Nezahrnuje člen, který umožňuje načíst číslo týdne v roce. Chcete-li načíst týden v roce, zavolejte metodu jednotlivého kalendáře Calendar.GetWeekOfYear . 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 zachovat DateTime čtyřmi způsoby:

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

Zachování hodnot jako řetězců

K úspěšnému obnovení DateTime hodnot, které jsou trvalé jako řetězce, postupujte podle těchto pravidel:

  • Stejné předpoklady pro formátování specifické pro jazykovou verzi provádějte při obnovení řetězce jako při jeho zachování. Chcete-li zajistit, aby byl řetězec obnoven v systému, jehož aktuální jazyková verze je odlišná od jazykové verze systému, v němž byl uložen, zavolejte ToString přetížení pro uložení řetězce pomocí konvencí invariantní jazykové verze. Zavolejte metodu Parse(String, IFormatProvider, DateTimeStyles) nebo TryParse(String, IFormatProvider, DateTimeStyles, DateTime) přetížení pro obnovení řetězce pomocí konvencí invariantní jazykové verze. Nikdy nepoužívejte ToString() Parse(String) přetížení, nebo, TryParse(String, DateTime) která používají konvence aktuální jazykové verze.

  • Pokud datum představuje jednorázový čas, ujistěte se, že představuje stejný okamžik v čase, kdy je obnovena, a to i v jiném časovém pásmu. DateTimePřed uložením hodnotu převeďte na koordinovaný světový č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 dat typu DateTime a časového pásma.

Nejběžnější chyba vytvořená při zachování DateTime hodnot jako řetězců je spoléhat na konvence formátování výchozí nebo aktuální jazykové verze. K problémům dojde, pokud je aktuální jazyková verze při ukládání a obnovování řetězců odlišná. Následující příklad znázorňuje tyto problémy. Ukládá pět kalendářních dat pomocí formátovacích úmluv aktuální jazykové verze, což je v tomto případě angličtina (USA). Obnoví data pomocí formátovacích úmluv 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ě data a zbývající tři data budou interpretována nesprávně. Také pokud původní hodnoty data a času představují jednorázový čas v čase, jsou obnoveny nesprávné časy, protože informace o časovém pásmu jsou ztraceny.

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

K DateTime úspěšnému přenosu hodnot použijte následující postup:

  1. Pokud hodnoty reprezentují jednorázový čas, převeďte je z místního času na čas UTC voláním ToUniversalTime metody.
  2. Převeďte data na jejich řetězcové reprezentace voláním ToString(String, IFormatProvider) String.Format(IFormatProvider, String, Object[]) metody nebo přetížení. Použijte konvence formátování invariantní jazykové verze zadáním CultureInfo.InvariantCulture jako provider argument. Určete, zda má být hodnota zpátečního přenosu použita pomocí standardního formátovacího řetězce "O" nebo "R".

Chcete-li obnovit trvalé DateTime hodnoty bez ztráty dat, postupujte podle následujících kroků:

  1. Analyzujte data voláním metody ParseExact nebo TryParseExact přetížením. Zadejte CultureInfo.InvariantCulture jako provider argument a použijte stejný standardní formátovací řetězec, který jste použili pro format argument během převodu. DateTimeStyles.RoundtripKindDo argumentu zadejte hodnotu styles .
  2. Pokud DateTime hodnoty reprezentují jednorázový čas, zavolejte ToLocalTime metodu pro převedení analyzovaného data z času UTC na místní čas.

Následující příklad používá invariantní jazykovou verzi a standardní formátovací řetězec "O" pro zajištění, že DateTime hodnoty uložené a obnovené reprezentují stejný okamžik v čase bez ohledu na systém, jazykovou verzi nebo časové pásmo zdrojového a 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 impulsů. V takovém případě nemusíte uvažovat o jazykové verzi systémů, na které DateTime jsou hodnoty trvalé a obnoveny.

Chcete-li zachovat DateTime hodnotu jako celé číslo:

  • Pokud DateTime hodnoty reprezentují jediný okamžik v čase, převeďte je na čas UTC voláním ToUniversalTime metody.
  • Načte počet impulsů reprezentovaných DateTime hodnotou z její Ticks Vlastnosti.

Chcete-li obnovit DateTime hodnotu, která byla trvalá jako celé číslo:

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

Následující příklad uchovává pole DateTime hodnot jako celá čísla v systému v tichomořském časovém pásmu v USA. Obnoví ho v systému v zóně UTC. Soubor, který obsahuje celá čísla, obsahuje Int32 hodnotu, která označuje celkový počet Int64 hodnot, které se bezprostředně 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 DateTime prostřednictvím serializace do datového proudu nebo souboru a pak je obnovit pomocí deserializace. DateTime data jsou serializovaná v některém zadaném formátu objektu. Objekty jsou obnoveny při deserializaci. Formátovací modul nebo serializátor, například XmlSerializer nebo BinaryFormatter , zpracovávají proces serializace a deserializace. další informace o serializaci a typech serializace podporovaného .NET Framework naleznete v tématu serialization.

Následující příklad používá XmlSerializer třídu k serializaci a deserializaci DateTime hodnot. Hodnoty reprezentují všechny dny přestupnosti v dvacátém prvním století. Výstup představuje výsledek, pokud je příklad spuštěn v systému, jehož aktuální jazyková verze je angličtina (Velká Británie). Vzhledem k tomu, že jste deserializováni DateTime samotný objekt, kód nemusí zpracovávat kulturní rozdíly v formátech 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 DateTime hodnota představuje moment v čase a je vyjádřena jako místní čas, převeďte ji z místního času na čas UTC před serializací voláním ToUniversalTime metody. Po deserializaci ji převeďte z času UTC na místní čas voláním ToLocalTime metody. Následující příklad používá BinaryFormatter třídu k serializaci DateTime dat v systému v oblasti USA (běžný čas) a k jejímu deserializaci v systému v zóně centrálního standardu USA.

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 času v časovém pásmu

V předchozích příkladech se předpokládá, že DateTime se hodnoty vyjadřují jako místní časy. Kód převedl hodnoty mezi časem 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 moment v čase v jiném časovém pásmu než místní a UTC. Vzhledem k tomu DateTime , že struktura nezohledňuje časová pásma, je nutné serializovat jak hodnotu, tak i DateTime TimeZoneInfo objekt, který představuje své časové pásmo. Vytvořte typ, jehož pole obsahují jak DateTime hodnotu, tak 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é

DateWithTimeZoneStruktura 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 Visual Basic nebo C# z úložiště docs v GitHub.

Pomocí DateWithTimeZone struktury 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 volá BinaryFormatter.Deserialize metodu pro její 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

DateTime TimeSpan Typy hodnot a se liší v tom, že DateTime představuje okamžitý čas, zatímco TimeSpan představuje časový interval. Můžete odečíst jednu instanci DateTime z druhé a získat tak TimeSpan objekt, který představuje časový interval mezi nimi. Nebo můžete přidat kladnou TimeSpan hodnotu k aktuálnímu DateTime pro získání DateTime hodnoty, která představuje budoucí datum.

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

Porovnávání pro rovnost v rámci tolerance

Porovnávání rovnosti pro DateTime hodnoty je přesné. To znamená, že dvě hodnoty musí být vyjádřeny jako stejný počet značek, které mají být považovány za stejné. Tato přesnost je často pro mnoho aplikací zbytečná nebo dokonce nesprávná. Často je vhodné otestovat, zda DateTime jsou objekty zhruba stejné.

Následující příklad ukazuje, jak porovnat zhruba ekvivalentní DateTime hodnoty. Při deklaraci rovnosti přijímá malý okraj rozdílu.

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

DateTimeHodnota, která se přenáší do aplikace modelu COM, se pak přenese zpátky do spravované aplikace, která se označuje jako operace odezvy. DateTimeHodnota, která specifikuje jenom čas, ale nezaokrouhluje, jak by to bylo možné očekávat.

Pokud se operace Round-Trip jenom časem, například 3 hodiny, konečné datum a čas končí 30.1899 0001 v 3:00 hodiny místo ledna, 1, 0001 0001 v 3:00. odp. .NET Framework a COM předpokládají výchozí datum, je-li zadán pouze čas. systém COM však předpokládá základní datum 30. prosince 1899 0001, zatímco .NET Framework předpokládá základní datum v lednu, 1, 0001 0001.

pokud je předána pouze doba z .NET Framework do modelu com, je prováděno speciální zpracování, které převede čas na formát používaný modelem COM. pokud je předán pouze čas z modelu COM do .NET Framework, není provedeno žádné zvláštní zpracování, protože by došlo k poškození legitimního data a času do 30. prosince 1899. pokud datum začíná zpáteční cestou z modelu com, .NET Framework a model com zachovávají datum.

chování .NET Framework a modelu COM znamená, že pokud vaše aplikace bude DateTime zapomenout, že pouze určuje čas, aplikace musí pamatovat na změnu nebo ignorovat chybné datum z poslední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 DateTime struktury na zadaný rok, měsíc a den pro zadaný kalendář.

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

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

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

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

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

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

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

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

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

Inicializuje novou instanci struktury pro zadaný DateTime 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 struktury pro zadaný DateTime rok, měsíc, den, hodinu, minutu, sekundu, milisekundu a koordinovaný univerzální čas (UTC) nebo místní čas pro zadaný kalendář.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, 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.

DateTime(Int64)

Inicializuje novou instanci DateTime struktury na zadaný počet tiků.

DateTime(Int64, DateTimeKind)

Inicializuje novou instanci DateTime struktury na zadaný počet tiků a koordinovaný světový čas (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

Načte den v měsíci reprezentovaný touto instancí.

DayOfWeek

Vrátí den v týdnu reprezentovaný touto instancí.

DayOfYear

Získá den v roce reprezentovaný touto instancí.

Hour

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

Kind

Získá hodnotu, která určuje, zda čas reprezentovaný touto instancí je založen na místním čase, koordinovaném univerzálním čase (UTC), nebo ani jedno.

Millisecond

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

Minute

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

Month

Načte komponentu měsíce data reprezentované touto instancí.

Now

Získá DateTime objekt, který je nastaven na aktuální datum a čas v tomto počítači 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í novou DateTime hodnotu , která přidá hodnotu zadanou k hodnotě této TimeSpan instance.

AddDays(Double)

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

AddHours(Double)

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

AddMilliseconds(Double)

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

AddMinutes(Double)

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

AddMonths(Int32)

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

AddSeconds(Double)

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

AddTicks(Int64)

Vrátí novou hodnotu, která přidá zadaný počet značek DateTime k hodnotě této instance.

AddYears(Int32)

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

Compare(DateTime, DateTime)

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

CompareTo(DateTime)

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

CompareTo(Object)

Porovná hodnotu této instance se zadaným objektem, který obsahuje zadanou DateTime hodnotu, a vrátí celé číslo, které označuje, zda je tato instance starší než, stejná jako nebo vyšší než 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 specifikátorem standardního formátu data a času a informacemi o formátování specifickém 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í pro TypeCode typ hodnoty DateTime .

IsDaylightSavingTime()

Určuje, jestli se tato instance DateTime nachází v časovém rozsahu letního času pro aktuální časové pásmo.

IsLeapYear(Int32)

Vrátí údaj o tom, jestli je zadaný rok posouný.

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ý objekt, který má stejný počet kmitání jako zadaný , ale je určen buď jako místní čas, koordinovaný univerzální čas (UTC), nebo žádný, jak je uvedeno DateTime DateTime zadanou DateTimeKind hodnotou.

Subtract(DateTime)

Vrátí novou TimeSpan hodnotu, která odečte zadané datum a čas od hodnoty této instance.

Subtract(TimeSpan)

Vrátí novou DateTime hodnotu, která odečte zadanou dobu trvání 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 objektu na odpovídající reprezentaci DateTime řetězce dlouhého data.

ToLongTimeString()

Převede hodnotu aktuálního objektu na odpovídající reprezentaci DateTime dlouhého řetězce.

ToOADate()

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

ToShortDateString()

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

ToShortTimeString()

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

ToString()

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

ToString(IFormatProvider)

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

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 na poskytnutý rozsah znaků.

TryParse(ReadOnlySpan<Char>, DateTime)

Převede zadaný znak span rozsahu data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

Převede reprezentace rozsahu data a času na jeho DateTime ekvivalent pomocí zadaných informací o formátování a stylu formátování specifické jazykové verze a vrátí hodnotu, která označuje, zda byl převod úspěšný.

TryParse(String, DateTime)

Převede určenou řetězcovou reprezentaci data a času na její DateTime ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Převede zadanou řetězcovou reprezentaci data a času na svůj DateTime ekvivalent pomocí zadaných informací o formátování a stylu formátování specifické jazykové verze a vrátí hodnotu, která označuje, zda byl převod úspěšný.

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

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. Metoda vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

Převede zadaný znak span rozsahu data a času na jeho DateTime ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

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. 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 do zadaného data a času a vrátí nový datum a čas.

Equality(DateTime, DateTime)

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

GreaterThan(DateTime, DateTime)

Určuje, zda je jeden z určených DateTime pozdější než jiné DateTime .

GreaterThanOrEqual(DateTime, DateTime)

Určuje, zda jeden ze zadaných hodnot DateTime představuje datum a čas, který je stejný jako nebo pozdější než jiné zadané DateTime .

Inequality(DateTime, DateTime)

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

LessThan(DateTime, DateTime)

Určuje, zda je jeden ze zadaných hodnot DateTime dřívější než jiné DateTime .

LessThanOrEqual(DateTime, DateTime)

Určuje, zda jeden ze zadaných hodnot DateTime představuje datum a čas, který je stejný jako nebo dřívější než jiné zadané DateTime .

Subtraction(DateTime, DateTime)

Odečte zadané datum a čas z 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í hodnotu TypeCode pro tuto instanci.

IConvertible.ToBoolean(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToByte(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToChar(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToDateTime(IFormatProvider)

Vrátí aktuální DateTime objekt.

IConvertible.ToDecimal(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToDouble(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToInt16(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToInt32(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToInt64(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToSByte(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToSingle(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku 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. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToUInt32(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToUInt64(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Naplní SerializationInfo objekt 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é