DateTime Структура

Определение

Представляет текущее время, обычно выраженное как дата и время суток.

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, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, 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 readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, 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
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    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, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
Наследование
DateTime
Атрибуты
Реализации

Комментарии

Важно!

Эры в японских календарях основаны на периодах царствования императоров. Таким образом, ожидается наступление новой эры. Например, 1 мая 2019 года в JapaneseCalendar и JapaneseLunisolarCalendar отмечено как начало эры Рэйва. Изменение эры затрагивает все приложения, использующие эти календари. Дополнительные сведения и определение того, затрагиваются ли ваши приложения, см. в разделе Обработка новой эры в японском календаре в .NET. сведения о тестировании приложений на Windows системах для обеспечения их готовности к изменению эры см. в разделе подготовка приложения к изменению японской эры. Дополнительные сведения о функциях .NET, поддерживающих календари с несколькими Эр, и рекомендации при работе с календарями, поддерживающими несколько эр, см. в разделе Работа с Эр.

Примечание

Некоторые примеры C# в этой статье выполняются во встроенном средстве выполнения кода и на площадке Try.NET. Нажмите на кнопку Выполнить, чтобы выполнить пример в интерактивном окне. После выполнения кода вы можете изменить его и выполнить измененный код, снова нажав на кнопку Выполнить. Либо в интерактивном окне выполняется измененный код, либо, если компиляция завершается с ошибкой, в интерактивном окне отображаются все сообщения об ошибках компилятора C#.

Местный часовой пояс площадки и средства запуска встроенного кода Try.NET указан в формате UTC. Это может повлиять на работу и выходные данные примеров, иллюстрирующих DateTime, DateTimeOffset, типы TimeZoneInfo и их члены.

В этой статье приведено несколько примеров использования DateTime типа:

Примеры инициализации

Форматирование DateTime объектов в виде строк

Синтаксический анализ строк в виде DateTime объектов

DateTime Разрешение

Язык и календари

Сохраняемость

В этом разделе содержатся разделы для многих распространенных вариантов DateTime использования структуры:

Тип DateTime значения представляет даты и время со значениями в диапазоне от 00:00:00 (полночь), 1 января 0001 Года Анно Домини (Общая эра) до 11:59:59 вечера, 31 декабря 9999 г. по григорианскому календарю.

Значения времени измеряются в 100 наносекундных единицах, называемых тактовами. Конкретная дата — это количество тактов с полуночи 12:00, 1 января 0001 года A.D. (C.E.) в календаре GregorianCalendar . Число исключает такты, которые будут добавлены на високосные секунды. Например, значение тактов 31241376000000000000L представляет дату пятницы, 01 января 0100 12:00:00 полуночи. DateTime Значение всегда выражается в контексте явного или стандартного календаря.

Примечание

Если вы работаете со значением тактов, которое требуется преобразовать в другой интервал времени, например минуты или секунды, следует использовать TimeSpan.TicksPerDayдля преобразования значение , TimeSpan.TicksPerHourили TimeSpan.TicksPerMinuteTimeSpan.TicksPerSecondTimeSpan.TicksPerMillisecond константу. Например, чтобы добавить количество секунд, представленное указанным числом тактов, к Second компоненту DateTime значения, можно использовать выражение dateValue.Second + nTicks/Timespan.TicksPerSecond.

Вы можете просмотреть источник для всего набора примеров из этой статьи в Visual Basic, F# или C# из репозитория документации на сайте GitHub.

Примечание

Альтернативой DateTime структуре для работы со значениями даты и времени в определенных часовых поясах является DateTimeOffset структура. Структура DateTimeOffset хранит сведения о дате и времени в частном DateTime поле, а также количество минут, в течение которых дата и время отличаются от utc в частном Int16 поле. Это позволяет DateTimeOffset значению отражать время в определенном часовом поясе, тогда как DateTime значение может однозначно отражать только время UTC и местное время часового пояса. Обсуждение того, когда следует использовать структуру DateTime или DateTimeOffset структуру при работе со значениями даты и времени, см. в разделе "Выбор между dateTime", "DateTimeOffset", "TimeSpan" и "TimeZoneInfo".

Инициализация объекта DateTime

Начальное значение можно назначить новому DateTime значению различными способами:

  • Вызов конструктора, в котором указываются аргументы для значений, или используйте неявный конструктор без параметров.
  • DateTime Назначение возвращаемого значения свойства или метода.
  • Анализ значения из строкового DateTime представления.
  • Использование функций языка, зависящих от Visual Basic, для создания экземпляра DateTime.

В следующих фрагментах кода показаны примеры каждого из них:

Вызов конструкторов

Вызывается любая перегрузка конструктора DateTime , указывающая элементы значения даты и времени (например, год, месяц и день, или количество тактов). Следующий код создает определенную дату с помощью конструктора DateTime , указывающего год, месяц, день, час, минуту и секунду.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);
let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"

DateTime Если требуется DateTime инициализировать значение по умолчанию, вызывается неявный конструктор структуры без параметров. (Дополнительные сведения о неявном конструкторе без параметров типа значения см. в разделе "Типы значений".) Некоторые компиляторы также поддерживают объявление DateTime значения без явного присвоения ему значения. Создание значения без явной инициализации также приводит к значению по умолчанию. В следующем примере показан DateTime неявный конструктор без параметров в C# и Visual Basic, а также 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));
let dat1 = DateTime()

// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"

// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"
Назначение вычисляемого значения

Объект можно назначить DateTime значение даты и времени, возвращаемое свойством или методом. В следующем примере назначается текущая дата и время, текущая дата и время в формате UTC, а также текущая дата для трех новых DateTime переменных.

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;
let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today
Анализ строки, представляющей dateTime

ParseExactTryParse, Parseи TryParseExact методы преобразуют строку в эквивалентное значение даты и времени. В следующих примерах используются Parse методы и ParseExact методы для синтаксического анализа строки и преобразования ее в DateTime значение. Во втором формате используется форма, поддерживаемая стандартом ISO 8601 для представления даты и времени в строковом формате. Это стандартное представление часто используется для передачи сведений о дате в веб-службах.

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);
let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

Методы TryParse указывают TryParseExact , является ли строка допустимым представлением DateTime значения и, если она есть, выполняет преобразование.

Синтаксис, зависящий от языка для Visual Basic

Следующий оператор Visual Basic инициализирует новое DateTime значение.

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

Значения DateTime и их строковые представления

На внутреннем языке все DateTime значения представлены как количество тактов (число 100-наносекундных интервалов), прошедших с 12:00:00 полночь, 1 января 0001 г. Фактическое DateTime значение не зависит от способа отображения этого значения. Внешний DateTime вид значения является результатом операции форматирования, которая преобразует значение в строковое представление.

Внешний вид значений даты и времени зависит от языка и региональных параметров, международных стандартов, требований к приложениям и личных предпочтений. Структура DateTime обеспечивает гибкость при форматировании значений даты и времени с помощью перегрузок ToString. Метод по умолчанию DateTime.ToString() возвращает строковое представление значения даты и времени, используя короткий шаблон даты и времени текущего языка и региональных параметров. В следующем примере используется метод по умолчанию DateTime.ToString() . Она отображает дату и время, используя короткий шаблон даты и длительного времени для текущего языка и региональных параметров. Язык и региональные параметры en-US — это текущий язык и региональные параметры на компьютере, на котором был запущен пример.

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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{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

Для поддержки веб-сценариев, где сервер может находиться в разных языках и региональных параметрах, может потребоваться отформатировать даты в определенном языке и региональных параметрах. Вы указываете язык и региональные параметры с помощью DateTime.ToString(IFormatProvider) метода для создания короткого представления даты и длительного времени в определенном языке и региональных параметрах. В следующем примере метод используется 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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

Для других приложений могут потребоваться различные строковые представления даты. Метод DateTime.ToString(String) возвращает строковое представление, определенное описательом стандартного или настраиваемого формата с помощью соглашений о форматировании текущего языка и региональных параметров. В следующем примере метод используется DateTime.ToString(String) для отображения полного шаблона даты и времени для языка и региональных параметров en-US, текущего языка и региональных параметров на компьютере, на котором был запущен пример.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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

Наконец, можно указать язык и региональные параметры и формат с помощью DateTime.ToString(String, IFormatProvider) метода. В следующем примере метод используется DateTime.ToString(String, IFormatProvider) для отображения полного шаблона даты и времени для языка и региональных параметров 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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

Перегрузку DateTime.ToString(String) также можно использовать со строкой настраиваемого формата для указания других форматов. В следующем примере показано, как форматировать строку с помощью стандартного формата ISO 8601 , часто используемого для веб-служб. Формат Iso 8601 не имеет соответствующей строки стандартного формата.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00
Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00

Дополнительные сведения о форматировании DateTime значений см. в статье "Стандартные строки формата даты и времени " и "Настраиваемые строки формата даты и времени".

Анализ значений DateTime из строк

Синтаксический анализ преобразует строковое представление даты и времени в DateTime значение. Как правило, строки даты и времени имеют два разных использования в приложениях:

  • Дата и время принимает различные формы и отражает соглашения текущего языка и региональных параметров или конкретного языка и региональных параметров. Например, приложение позволяет пользователю, для которого используется язык и региональные параметры en-US, ввести значение даты как "12.15.2013" или "15 декабря 2013 г.". Он позволяет пользователю, для которого используется язык и региональные параметры en-gb, вводить значение даты как "15.12.2013" или "15 декабря 2013 г.".

  • Дата и время представлены в предопределенном формате. Например, приложение сериализует дату как "20130103" независимо от языка и региональных параметров, в которых выполняется приложение. Приложению может потребоваться ввести даты в коротком формате даты текущего языка и региональных параметров.

Используйте метод или TryParse метод для преобразования строки из одного из общих форматов даты и времени, используемых языком и региональными Parse параметрами, в DateTime значение. В следующем примере показано, как преобразовать TryParse строки даты в разных форматах языка и региональных параметров в DateTime значение. Он изменяет текущий язык и региональные параметры на английский (Великобритания) и вызывает GetDateTimeFormats() метод для создания массива строк даты и времени. Затем он передает каждому элементу в массиве методу TryParse . В выходных данных примера показано, что метод синтаксического анализа смог успешно преобразовать каждую из строк даты и времени, относящихся к языку и региональным параметрам.

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.
System.Threading.Thread.CurrentThread.CurrentCulture <-
    System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"

let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()

printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
    match DateTime.TryParse dateString with
    | true, parsedDate ->
        printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
    | _ ->
        badFormats.Add dateString

// Display strings that could not be parsed.
if badFormats.Count > 0 then
    printfn "\nStrings that could not be parsed: "
    for badFormat in badFormats do
        printfn $"   {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

Используйте ParseExact TryParseExact методы для преобразования строки, которая должна соответствовать определенному формату или формату DateTime значения. Вы указываете одну или несколько строк формата даты и времени в качестве параметра для метода синтаксического анализа. В следующем примере метод используется TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) для преобразования строк, которые должны быть либо в формате yyMdd, либо в формате HHmmss в DateTime значения.

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
let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings = 
    [ "20130816"; "20131608"; "  20130816   "
      "115216"; "521116"; "  115216  " ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, null,
                                System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
                                System.Globalization.DateTimeStyles.AdjustToUniversal) with
    | true, parsedDate ->
        printfn $"{dateString} --> {parsedDate:g}"
    | _ ->
        printfn $"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

Одним из распространенных способов ParseExact является преобразование строкового представления из веб-службы, обычно в стандартном формате ISO 8601 . В следующем коде показана правильная строка формата для использования:

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

printfn $"{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}")

Если не удается проанализировать строку, Parse методы вызывают ParseExact исключение. Методы TryParse возвращают TryParseExact Boolean значение, указывающее, выполнено ли преобразование успешно или завершилось сбоем. В сценариях, где важна производительность, следует использовать TryParse методы или TryParseExact методы. Операция синтаксического анализа для строк даты и времени, как правило, имеет высокую частоту сбоев, и обработка исключений является дорогостоящей. Используйте эти методы, если строки являются входными пользователями или поступающими из неизвестного источника.

Дополнительные сведения об анализе значений даты и времени см. в разделе "Синтаксический анализ строк даты и времени".

Значения даты и времени

Описания значений времени в типе DateTime часто выражаются с помощью стандарта UTC. Скоординированное универсальное время является международно признанным именем среднего времени Гринвича (GMT). Координированное универсальное время — это время, измеряемое с нулевой долготой, точкой начала в формате UTC. Летнее время неприменимо к UTC.

Местное время относительно определенного часового пояса. Часовой пояс связан со смещением часового пояса. Смещение часового пояса — это смещение часового пояса, измеряемого в часах с точки начала в формате UTC. Кроме того, локальное время при необходимости влияет на летнее время, которое добавляет или вычитает корректировку интервала времени. Местное время вычисляется путем добавления смещения часового пояса в формат UTC и настройки летнего времени при необходимости. Смещение часового пояса в точке начала в формате UTC равно нулю.

Время в формате UTC подходит для вычислений, сравнений и хранения дат и времени в файлах. Местное время подходит для отображения в пользовательских интерфейсах классических приложений. Приложения с поддержкой часовых поясов (например, многие веб-приложения) также должны работать с рядом других часовых поясов.

Kind Если свойство DateTime объекта DateTimeKind.Unspecifiedимеет значение, оно не указано, является ли представленное время местным временем, временем UTC или временем в другом часовом поясе.

Разрешение даты и времени

Примечание

В качестве альтернативы выполнению арифметических DateTime значений даты и времени для измерения затраченного времени можно использовать Stopwatch класс.

Свойство Ticks выражает значения даты и времени в единицах одной десятимиллионой секунды. Свойство Millisecond возвращает тысячные числа секунд в значении даты и времени. Использование повторяемых вызовов DateTime.Now свойства для измерения затраченного времени зависит от системных часов. Системные часы в системах Windows 7 и Windows 8 имеют разрешение примерно в 15 миллисекунд. Это разрешение влияет на небольшие интервалы времени менее 100 миллисекундах.

В следующем примере показана зависимость текущих значений даты и времени от разрешения системных часов. В этом примере внешний цикл повторяется 20 раз, а внутренний цикл служит для задержки внешнего цикла. Если значение счетчика внешнего цикла равно 10, вызов Thread.Sleep метода вводит задержку в пять миллисекундах. В следующем примере показано количество миллисекундах, возвращаемых свойством DateTime.Now.Milliseconds , только после вызова 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.
let mutable output = ""
for i = 0 to 20 do
    output <- output + $"{DateTime.Now.Millisecond}\n"
    // Introduce a delay loop.
    for _ = 0 to 1000 do ()

    if i = 10 then
        output <- output + "Thread.Sleep called...\n"
        System.Threading.Thread.Sleep 5

printfn $"{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

Операции DateTime

Вычисление, использующее структуру DateTime , например Add или Subtract, не изменяет значение структуры. Вместо этого вычисление возвращает новую DateTime структуру, значение которой является результатом вычисления.

Операции преобразования между часовыми поясами (например, между UTC и местным временем или между одним часовыми поясами и другим) учитывают летнее время, но арифметические операции и операции сравнения не учитываются.

Сама DateTime структура обеспечивает ограниченную поддержку преобразования из одного часового пояса в другой. Этот метод можно использовать для ToLocalTime преобразования utc в местное время или ToUniversalTime для преобразования из местного времени в формат UTC. Однако полный набор методов преобразования часовых поясов доступен в TimeZoneInfo классе. Вы преобразуете время в любой из часовых поясов мира в любой другой часовой пояс с помощью этих методов.

Вычисления и сравнения DateTime объектов имеют смысл только в том случае, если объекты представляют время в одном часовом поясе. Объект можно использовать для TimeZoneInfo представления часового DateTime пояса значения, хотя они слабо связаны. Объект DateTime не имеет свойства, возвращающего объект, представляющий часовой пояс этого значения даты и времени. Свойство Kind указывает, представляет ли DateTime значение UTC, местное время или не указано. В приложении, поддерживающем часовой пояс, необходимо использовать некоторый внешний механизм, чтобы определить часовой пояс, в котором DateTime был создан объект. Можно использовать структуру, которая заключает как значение, DateTime так и TimeZoneInfo объект, представляющий DateTime часовой пояс значения. Дополнительные сведения об использовании UTC в вычислениях и сравнениях со значениями DateTime см. в разделе "Выполнение арифметических операций с датами и временем".

Каждый DateTime член неявно использует григорианский календарь для выполнения своей операции. Исключения — это методы, которые неявно указывают календарь. К ним относятся конструкторы, указывающие календарь и методы с параметром, производным от IFormatProvider, например System.Globalization.DateTimeFormatInfo.

Операции, выполняемые членами типа, учитывают такие сведения, как високосные DateTime годы и количество дней в месяц.

Значения даты и времени и календари

Библиотека классов платформа .NET Framework включает несколько классов календаря, все из которых являются производными от Calendar класса. К ним относятся:

Важно!

Эры в японских календарях основаны на периодах царствования императоров. Таким образом, ожидается наступление новой эры. Например, 1 мая 2019 года в JapaneseCalendar и JapaneseLunisolarCalendar отмечено как начало эры Рэйва. Изменение эры затрагивает все приложения, использующие эти календари. Дополнительные сведения и определение того, затрагиваются ли ваши приложения, см. в разделе Обработка новой эры в японском календаре в .NET. сведения о тестировании приложений на Windows системах для обеспечения их готовности к изменению эры см. в разделе подготовка приложения к изменению японской эры. Дополнительные сведения о функциях .NET, поддерживающих календари с несколькими Эр, и рекомендации при работе с календарями, поддерживающими несколько эр, см. в разделе Работа с Эр.

Каждый язык и региональные параметры используют календарь по умолчанию, определенный свойством только для CultureInfo.Calendar чтения. Каждый язык и региональные параметры могут поддерживать один или несколько календарей, определенных свойством только для CultureInfo.OptionalCalendars чтения. Календарь, используемый в данный момент определенным CultureInfo объектом, определяется его DateTimeFormatInfo.Calendar свойством. Он должен быть одним из календарей, найденных в массиве CultureInfo.OptionalCalendars .

Текущий календарь языка и региональных параметров используется во всех операциях форматирования для этого языка и региональных параметров. Например, по умолчанию календарь тайской буддийской культуры является тайским буддийским календарем эры, который представлен классом ThaiBuddhistCalendar . CultureInfo Если объект, представляющий тайскую буддийскую культуру, используется в операции форматирования даты и времени, по умолчанию используется тайский календарь буддийской эры. Григорианский календарь используется только в том случае, если свойство языка и региональных DateTimeFormatInfo.Calendar параметров изменяется, как показано в следующем примере:

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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)

printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()

printfn $"{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

Текущий календарь языка и региональных параметров также используется во всех операциях синтаксического анализа для этого языка и региональных параметров, как показано в следующем примере.

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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{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

Создайте экземпляр DateTime значения, используя элементы даты и времени (число года, месяца и дня) определенного календаря, вызвав конструктор DateTime , включающий calendar параметр и передав объект Calendar , представляющий этот календарь. В следующем примере используются элементы даты и времени из ThaiBuddhistCalendar календаря.

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
let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)

printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"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 Конструкторы, не содержащие calendar параметр, предполагают, что элементы даты и времени выражаются как единицы в григорианском календаре.

Все остальные DateTime свойства и методы используют григорианский календарь. Например, DateTime.Year свойство возвращает год в григорианском календаре, а DateTime.IsLeapYear(Int32) метод предполагает, что year параметр является годом в григорианском календаре. Каждый DateTime член, использующий григорианский календарь, имеет соответствующий член Calendar класса, использующего определенный календарь. Например, Calendar.GetYear метод возвращает год в определенном календаре, а Calendar.IsLeapYear метод интерпретирует year параметр как число года в определенном календаре. В следующем примере используются и DateTime соответствующие члены ThaiBuddhistCalendar класса.

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
let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"

printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"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

Структура DateTime включает DayOfWeek свойство, которое возвращает день недели в григорианском календаре. Он не содержит члена, который позволяет получить номер недели года. Чтобы получить неделю года, вызовите метод отдельного календаря Calendar.GetWeekOfYear . Ниже приведен пример.

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
let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"

let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"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

Дополнительные сведения о датах и календарях см. в статье "Работа с календарями".

Сохранение значений DateTime

Значения можно сохранять DateTime четырьмя способами:

Необходимо убедиться, что подпрограмма, которая восстанавливает DateTime значения, не теряет данные или создает исключение независимо от выбранного метода. DateTime Значения должны быть круговой путь. То есть исходное и восстановленное значение должны совпадать. Если исходное DateTime значение представляет собой один момент времени, он должен определить тот же момент времени, когда он восстанавливается.

Сохранение значений в виде строк

Чтобы успешно восстановить DateTime значения, которые сохраняются в виде строк, выполните следующие правила:

  • Сделайте те же предположения о форматировании, зависят от языка и региональных параметров при восстановлении строки, как и при сохранении. Чтобы обеспечить восстановление строки в системе, текущая культура которой отличается от языка и региональных параметров системы, в которой она была сохранена, вызовите ToString перегрузку, чтобы сохранить строку с помощью соглашений инвариантного языка и региональных параметров. Вызовите или TryParse(String, IFormatProvider, DateTimeStyles, DateTime) перегрузку Parse(String, IFormatProvider, DateTimeStyles) для восстановления строки с помощью соглашений инвариантного языка и региональных параметров. Никогда не используйте ToString()Parse(String)TryParse(String, DateTime) или перегрузки, которые используют соглашения текущего языка и региональных параметров.

  • Если дата представляет один момент времени, убедитесь, что она представляет тот же момент времени при восстановлении, даже в другом часовом поясе. Перед сохранением значения преобразуйте DateTime значение в формате UTC. Можно также сериализовать значение вместе с сведениями о часовом поясе. Дополнительные сведения об этом подходе см. в разделе "Сериализация данных даты и времени и часового пояса".

Наиболее распространенной ошибкой при сохранении DateTime значений в виде строк является использование соглашений о форматировании по умолчанию или текущего языка и региональных параметров. Проблемы возникают, если текущий язык и региональные параметры отличаются при сохранении и восстановлении строк. В следующем примере показаны эти проблемы. Он сохраняет пять дат с помощью соглашений о форматировании текущего языка и региональных параметров, которые в данном случае являются английским (США). Она восстанавливает даты с помощью соглашений о форматировании другого языка и региональных параметров, что в данном случае — английский (Великобритания). Так как соглашения о форматировании двух языков и региональных параметров отличаются, две даты невозможно восстановить, а остальные три даты интерпретируются неправильно. Кроме того, если исходные значения даты и времени представляют отдельные моменты во времени, время восстановления неверно, так как сведения о часовом поясе теряются.

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...
let saveLocalDatesAsString () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date}"
            string date ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreLocalDatesFromString () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParse inputValue with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue:f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsLocalStrings () =
    saveLocalDatesAsString ()
    restoreLocalDatesFromString ()

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

Чтобы успешно выполнить значения кругового пути DateTime , выполните следующие действия.

  1. Если значения представляют отдельные моменты времени, преобразуйте их из местного времени в utc путем вызова ToUniversalTime метода.
  2. Преобразуйте даты в их строковые представления путем вызова или String.Format(IFormatProvider, String, Object[]) перегрузкиToString(String, IFormatProvider). Используйте соглашения о форматировании инвариантного языка и региональных параметров, указав CultureInfo.InvariantCulture его в качестве аргумента provider . Укажите, что значение должно выполнять циклический переход с помощью строки стандартного формата "O" или "R".

Чтобы восстановить сохраненные DateTime значения без потери данных, выполните следующие действия.

  1. Анализ данных путем вызова или TryParseExact перегрузкиParseExact. Укажите CultureInfo.InvariantCulture в качестве аргумента provider и используйте ту же строку стандартного формата, которую вы использовали для аргумента format во время преобразования. DateTimeStyles.RoundtripKind Включите значение в styles аргумент.
  2. DateTime Если значения представляют отдельные моменты времени, вызовите ToLocalTime метод для преобразования проанализированной даты из UTC в местное время.

В следующем примере используется инвариантный язык и региональные параметры и строка стандартного формата O для обеспечения того, чтобы DateTime сохраненные и восстановленные значения представляли тот же момент времени независимо от системы, языка и региональных параметров или часового пояса исходной и целевой систем.

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...
let saveDatesAsInvariantStrings () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreDatesAsInvariantStrings () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    
    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsInvariantStrings () =
    saveDatesAsInvariantStrings ()
    restoreDatesAsInvariantStrings ()

// 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...
Сохранение значений в виде целых чисел

Вы можете сохранить дату и время в виде Int64 значения, представляющего ряд тактов. В этом случае вам не нужно учитывать язык и региональные параметры систем DateTime , в которых сохраняются и восстанавливаются значения.

Чтобы сохранить DateTime значение в виде целого числа, выполните приведенные далее действия.

  • DateTime Если значения представляют отдельные моменты во времени, преобразуйте их в формат UTC, вызвав ToUniversalTime метод.
  • Извлеките количество тактов, представленных значением DateTime из его Ticks свойства.

Чтобы восстановить DateTime значение, сохраненное в виде целого числа, выполните приведенные далее действия.

  1. Создайте экземпляр нового DateTime объекта, передав Int64 значение конструктору DateTime(Int64) .
  2. DateTime Если значение представляет один момент времени, преобразуйте его из UTC в местное время, вызвав ToLocalTime метод.

В следующем примере массив значений сохраняется в виде целых DateTime чисел в системе в тихоокеанском часовом поясе США. Он восстанавливает его в системе в зоне UTC. Файл, содержащий целые числа, содержит Int32 значение, указывающее общее количество значений Int64 , которые сразу же следуют за ним.

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...
let saveDatesAsInts () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    let ticks =
        [| for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().Ticks |]
    use fs = new FileStream(filenameInts, FileMode.Create)
    use bw = new BinaryWriter(fs)
    bw.Write ticks.Length

    for tick in ticks do
        bw.Write tick

    printfn "Saved dates..."

let restoreDatesAsInts () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    use fs = new FileStream(filenameInts, FileMode.Open)
    use br = new BinaryReader(fs)

    try
        let items = br.ReadInt32()
        let dates =
            [| for _ in 0..items do
                let ticks = br.ReadInt64()
                DateTime(ticks).ToLocalTime() |]

        printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
        for value in dates do
            printfn $"{value:f}"
    with 
    | :? EndOfStreamException ->
        printfn "File corruption detected. Unable to restore data..."
    | :? IOException ->
        printfn "Unspecified I/O error. Unable to restore data..."
    // Thrown during array initialization.
    | :? OutOfMemoryException ->
        printfn"File corruption detected. Unable to restore data..."

    printfn "Restored dates..."

let persistAsIntegers () =
    saveDatesAsInts ()
    restoreDatesAsInts ()

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

Сериализация значений DateTime

Вы можете сохранять DateTime значения путем сериализации в поток или файл, а затем восстанавливать их с помощью десериализации. DateTime данные сериализуются в определенном формате объекта. Объекты восстанавливаются при десериализации. Модуль форматирования или сериализатор, например XmlSerializer или BinaryFormatter, обрабатывает процесс сериализации и десериализации. Дополнительные сведения о сериализации и типах сериализации, поддерживаемых платформа .NET Framework, см. в разделе "Сериализация".

В следующем примере класс используется XmlSerializer для сериализации и десериализации DateTime значений. Значения представляют все високосные дни в двадцать первом веке. Выходные данные представляют результат, если пример выполняется в системе с текущим языком и региональными параметрами (Великобритания). Так как вы десериализовали DateTime сам объект, код не должен обрабатывать культурные различия в форматах даты и времени.

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
let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

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

В предыдущем примере не содержатся сведения о времени. DateTime Если значение представляет момент времени и выражается как локальное время, преобразуйте его из местного времени в формат UTC, прежде чем сериализовать его путем вызова ToUniversalTime метода. После десериализации преобразуйте его из UTC в местное время, вызвав ToLocalTime метод. В следующем примере используется BinaryFormatter класс для сериализации DateTime данных в системе в стандартном часовом поясе США и десериализации данных в системе в зоне центрального стандарта США.

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...
// BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDatesBinary () =
    let dates = 
        [| DateTime(2014, 6, 14, 6, 32, 0)
           DateTime(2014, 7, 10, 23, 49, 0)
           DateTime(2015, 1, 10, 1, 16, 0)
           DateTime(2014, 12, 20, 21, 45, 0)
           DateTime(2014, 6, 2, 15, 14, 0) |]
        |> Array.map (fun date -> 
            printfn $"{date:f}"
            date.ToUniversalTime() )

    use fs = new FileStream(filenameBin, FileMode.Create)
    let bin = BinaryFormatter()

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    bin.Serialize(fs, dates)
    printfn "Saved dates..."

let restoreDatesBinary () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use fs = new FileStream(filenameBin, FileMode.Open)
    let bin = BinaryFormatter()
    let dates = bin.Deserialize fs :?> DateTime []

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    for value in dates do
        printfn $"{value.ToLocalTime():f}"

    printfn "Restored dates..."

let persistBinary () =
    saveDatesBinary ()
    restoreDatesBinary ()

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

Сериализация данных даты и времени и часового пояса

В предыдущих примерах все предполагается, что DateTime значения выражаются как локальное время. Код преобразовал значения между UTC и местным временем, чтобы они отражали тот же момент времени в исходной и целевой системах. DateTime Значения могут также отражать моменты во времени в часовом поясе, отличном от локального и UTC. DateTime Так как структура не учитывает часовой пояс, необходимо сериализовать DateTime значение и TimeZoneInfo объект, представляющий его часовой пояс. Создайте тип, поля которого включают как значение, DateTime так и часовой пояс. В следующем примере определяется DateWithTimeZone структура.

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

open System

[<Serializable>]
type DateWithTimeZone =
    struct
        val TimeZone: TimeZoneInfo
        val DateTime: DateTime
        new (dateValue, timeZone) = 
            { DateTime = dateValue; 
              TimeZone = 
                if isNull timeZone then TimeZoneInfo.Local
                else timeZone }
    end
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

Важно!

Структура DateWithTimeZone используется в следующих двух примерах, которые сериализуют и десериализируют массив DateWithTimeZone объектов. Исходный код для всего набора примеров из этой статьи можно просмотреть в Visual Basic, F# или C# из репозитория документации на сайте GitHub.

Используя структуру DateWithTimeZone , можно сохранить дату и время вместе с сведениями о часовом поясе. В следующем примере класс используется BinaryFormatter для сериализации массива DateWithTimeZone объектов.

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
// BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

let saveDateWithTimeZone () =
    let dates = 
        [| DateWithTimeZone(DateTime(2014, 8, 9, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 15, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Pacific Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 22, 19, 30, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time")
           DateWithTimeZone(DateTime(2014, 8, 28, 19, 0, 0),
                                TimeZoneInfo.FindSystemTimeZoneById "Eastern Standard Time") |]

    use fs = new FileStream(@".\Schedule.bin", FileMode.Create)
    let formatter = BinaryFormatter()
    try
        formatter.Serialize(fs, dates)
        // Display dates.
        for date in dates do
            let tz = date.TimeZone
            printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
    with :? SerializationException as e ->
        printfn $"Serialization failed. Reason: {e.Message}"

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

В следующем примере вызывается BinaryFormatter.Deserialize метод для десериализации.

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
let restoreDateWithTimeZone () =
    let filename = @".\Schedule.bin"
    if File.Exists filename then
        use fs = new FileStream(filename, FileMode.Open)

        let formatter = BinaryFormatter()
        try
            let dates = formatter.Deserialize fs :?> DateWithTimeZone []
            // Display dates.
            for date in dates do
                let tz = date.TimeZone
                printfn $"{date.DateTime} {if tz.IsDaylightSavingTime date.DateTime then tz.DaylightName else tz.StandardName}"
        with :? SerializationException as e ->
            printfn $"Deserialization failed. Reason: {e.Message}"
    else
        printfn "Unable to find file to deserialize."

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

DateTime и TimeSpan

DateTime Типы значений TimeSpan отличаются тем, что a DateTime представляет момент времени, в то время как представляет TimeSpan интервал времени. Можно вычесть один экземпляр из другого DateTime , чтобы получить TimeSpan объект, представляющий интервал времени между ними. Или можно добавить положительный результат TimeSpan к текущему DateTime , чтобы получить DateTime значение, представляющее будущую дату.

Вы можете добавить или вычесть интервал времени из DateTime объекта. Интервалы времени могут быть отрицательными или положительными, и они могут быть выражены в таких единицах, как деления, секунды или как TimeSpan объект.

Сравнение равенства в пределах допустимости

Сравнения на равенство для DateTime значений точны. Это означает, что два значения должны быть выражены как одинаковое количество тактов, которые должны считаться равными. Эта точность часто является ненужной или даже неправильной для многих приложений. Часто требуется проверить DateTime , равны ли объекты.

В следующем примере показано, как сравнить примерно эквивалентные DateTime значения. Он принимает небольшое поле разницы при объявлении их равных.

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
let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
    let delta = 
        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
    
    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
    abs delta < windowInSeconds

let testRoughlyEquals () =
    let window = 10
    let window' = 10.
    let freq = 60 * 60 * 2 // 2 hours

    let d1 = DateTime.Now

    let d2 = d1.AddSeconds(2. * window')
    let d3 = d1.AddSeconds(-2. * window')
    let d4 = d1.AddSeconds(window' / 2.)
    let d5 = d1.AddSeconds(-window' / 2.)

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

    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"

    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
    printfn $"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

Рекомендации по взаимодействию COM

Значение DateTime , которое передается в COM-приложение, а затем передается обратно в управляемое приложение, как утверждается, для кругового пути. Однако значение, DateTime указывающее только время, не выполняет круговой путь, как можно ожидать.

Если вы циклически пройдете только время, например 3 P.M., последняя Дата и время — 30 декабря 1899 Н.Э. в 3:00, а не 1 января 0001 Г. в 13:00 В платформа .NET Framework и COM предполагается дата по умолчанию, если указано только время. Однако система COM предполагает базовую дату 30 декабря 1899 Г.Э., а платформа .NET Framework предполагает базовую дату 1 января 0001 Г.

Когда передается только время из платформа .NET Framework в COM, выполняется специальная обработка, которая преобразует время в формат, используемый COM. Когда передается только время из COM в платформа .NET Framework, специальная обработка не выполняется, так как это повреждает допустимые даты и время до 30 декабря 1899 г. Если дата начинает циклический переход с COM, платформа .NET Framework и COM сохраняют дату.

Поведение платформа .NET Framework и COM означает, что если приложение выполняет циклический переход только DateTime на определенное время, приложение должно помнить об изменении или пропуске ошибочной даты из конечного DateTime объекта.

Конструкторы

DateTime(Int32, Int32, Int32)

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца и дня.

DateTime(Int32, Int32, Int32, Calendar)

Инициализирует новый экземпляр структуры DateTime заданным годом, месяцем и днем для указанного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданным годом, месяцем, днем, часом, минутой и секундой.

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

Инициализирует новый экземпляр структуры DateTime указанным годом, месяцем, днем, часом, минутой и секундой для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты и секунды, а также временем UTC или местным временем.

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

Инициализирует новый экземпляр структуры DateTime заданным годом, месяцем, днем, часом, минутой, секундой и миллисекундой.

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

Инициализирует новый экземпляр структуры DateTime указанным годом, месяцем, днем, часом, минутой, секундой и миллисекундой для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем для заданного календаря.

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

Инициализирует новый экземпляр структуры DateTime заданными значениями года, месяца, дня, часа, минуты, секунды и миллисекунды, а также временем UTC или местным временем для заданного календаря.

DateTime(Int64)

Инициализирует новый экземпляр структуры DateTime заданным числом тактов.

DateTime(Int64, DateTimeKind)

Инициализирует новый экземпляр структуры DateTime заданным числом тактов и временем UTC или местным временем.

Поля

MaxValue

Представляет наибольшее возможное значение типа DateTime. Это поле доступно только для чтения.

MinValue

Представляет минимально допустимое значение типа DateTime. Это поле доступно только для чтения.

UnixEpoch

Значение этой константы эквивалентно 00:00:00.0000000 UTC 1 января 1970 г. по григорианскому календарю. UnixEpoch определяет момент времени, в который значение времени в формате Unix равно 0.

Свойства

Date

Возвращает компоненту даты этого экземпляра.

Day

Возвращает день месяца, представленный этим экземпляром.

DayOfWeek

Возвращает день недели, представленный этим экземпляром.

DayOfYear

Возвращает день года, представленный этим экземпляром.

Hour

Возвращает компонент часа даты, представленной этим экземпляром.

Kind

Возвращает значение, указывающее, на каком времени основано время, представленное этим экземпляром: местном, UTC или ни на том, ни на другом.

Microsecond

Компонент микросекунд, выраженный как значение от 0 до 999.

Millisecond

Возвращает компонент миллисекунд для даты, представленной в данном экземпляре.

Minute

Возвращает компонент минуты даты, представленной этим экземпляром.

Month

Возвращает компонент месяца даты, представленной этим экземпляром.

Nanosecond

Компонент nanoseconds, выраженный как значение от 0 до 900 (приращение 100 наносекунд).

Now

Возвращает объект DateTime, которому присвоены текущие дата и время данного компьютера, выраженные как местное время.

Second

Возвращает компонент секунды даты, представленной этим экземпляром.

Ticks

Возвращает число тактов, которое представляет дату и время этого экземпляра.

TimeOfDay

Возвращает время дня для этого экземпляра.

Today

Возвращает текущую дату.

UtcNow

Возвращает объект DateTime, которому присвоены текущие дата и время данного компьютера, выраженные в формате UTC.

Year

Возвращает компонент года даты, представленной этим экземпляром.

Методы

Add(TimeSpan)

Возвращает новый объект DateTime, добавляющий значение заданного объекта TimeSpan к значению данного экземпляра.

AddDays(Double)

Возвращает новый объект DateTime, добавляющий заданное число дней к значению данного экземпляра.

AddHours(Double)

Возвращает новый объект DateTime, добавляющий заданное число часов к значению данного экземпляра.

AddMicroseconds(Double)

Возвращает новое DateTime значение, которое добавляет указанное число микросекунд в значение этого экземпляра.

AddMilliseconds(Double)

Возвращает новый объект DateTime, добавляющий заданное число миллисекунд к значению данного экземпляра.

AddMinutes(Double)

Возвращает новый объект DateTime, добавляющий заданное число минут к значению данного экземпляра.

AddMonths(Int32)

Возвращает новый объект DateTime, добавляющий заданное число месяцев к значению данного экземпляра.

AddSeconds(Double)

Возвращает новый объект DateTime, добавляющий заданное число секунд к значению данного экземпляра.

AddTicks(Int64)

Возвращает новый объект DateTime, добавляющий заданное число тактов к значению данного экземпляра.

AddYears(Int32)

Возвращает новый объект DateTime, добавляющий заданное число лет к значению данного экземпляра.

Compare(DateTime, DateTime)

Сравнивает два экземпляра объекта DateTime и возвращает целое число, которое показывает, предшествует ли первый экземпляр второму, совпадает или расположен позже.

CompareTo(DateTime)

Сравнивает значение данного экземпляра с заданным значением DateTime и возвращает целочисленное значение, указывающее, когда наступает момент, заданный в данном экземпляре: раньше, позже или одновременно с моментом, заданным значением DateTime.

CompareTo(Object)

Сравнивает значение данного экземпляра с заданным объектом, содержащим заданное значение DateTime, и возвращает целочисленное значение, указывающее, когда наступает момент, заданный в данном экземпляре: раньше, позже или одновременно с моментом, заданным значением DateTime.

DaysInMonth(Int32, Int32)

Возвращает число дней в указанном месяце указанного года.

Equals(DateTime)

Возвращает значение, указывающее, равно ли значение данного экземпляра значению заданного экземпляра DateTime.

Equals(DateTime, DateTime)

Возвращает значение, указывающее, содержат ли два экземпляра DateTime одно и то же значение даты и времени.

Equals(Object)

Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.

FromBinary(Int64)

Десериализует 64-битовое значение и воссоздает исходный сериализованный объект DateTime.

FromFileTime(Int64)

Преобразует заданную временную характеристику файла Windows в ее эквивалент по местному времени.

FromFileTimeUtc(Int64)

Преобразует заданную временную характеристику файла Windows в ее UTC-эквивалент.

FromOADate(Double)

Возвращает объект DateTime, эквивалентный заданному значению даты OLE-автоматизации.

GetDateTimeFormats()

Преобразует значение этого экземпляра во все строковые представления, поддерживаемые стандартным форматом даты и времени.

GetDateTimeFormats(Char)

Преобразует значение этого экземпляра во все строковые представления, поддерживаемые указанным стандартным спецификатором формата даты и времени.

GetDateTimeFormats(Char, IFormatProvider)

Преобразует значение этого экземпляра во все строковые представления, поддерживаемые указанным стандартным спецификатором формата даты и времени и сведениями о форматировании, связанными с языком и региональными параметрами.

GetDateTimeFormats(IFormatProvider)

Преобразует значение этого экземпляра во все строковые представления, поддерживаемые стандартными спецификаторами формата даты и времени и указанными сведениями о форматировании, связанными с языком и региональными параметрами.

GetHashCode()

Возвращает хэш-код данного экземпляра.

GetTypeCode()

Возвращает TypeCode для типа значения DateTime.

IsDaylightSavingTime()

Указывает, попадает ли данный экземпляр объекта DateTime в диапазон летнего времени для текущего часового пояса.

IsLeapYear(Int32)

Возвращает сведения о том, является ли указанный год високосным.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Анализирует диапазон символов в значение.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Преобразует область памяти, которая содержит строковое представление даты и времени, в ее эквивалент DateTime, используя сведения о форматировании, связанные с языком и региональными параметрами, а также стиль форматирования.

Parse(String)

Преобразует строковое представление даты и времени в его DateTime эквивалент с помощью соглашений текущего языка и региональных параметров.

Parse(String, IFormatProvider)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя сведения о форматировании, связанные с языком и региональными параметрами.

Parse(String, IFormatProvider, DateTimeStyles)

Преобразует строковое представление даты и времени в его эквивалент DateTime, используя сведения о форматировании, связанные с языком и региональными параметрами, а также стиль форматирования.

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

Преобразует заданное представление диапазона даты и времени в его эквивалент DateTime, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату. В противном случае возникает исключение.

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

Преобразует заданное представление диапазона даты и времени в его эквивалент DateTime, используя заданный массив форматов, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать по крайней мере одному из заданных форматов. В противном случае возникает исключение.

ParseExact(String, String, IFormatProvider)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя указанные сведения о форматировании, связанные с языком и региональными параметрами. Формат строкового представления должен полностью соответствовать заданному формату.

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату. В противном случае возникает исключение.

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

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя заданный массив форматов, указанные сведения о форматировании, связанные с языком и региональными параметрами, и стиль форматирования. Формат строкового представления должен полностью соответствовать по крайней мере одному из заданных форматов. В противном случае возникает исключение.

SpecifyKind(DateTime, DateTimeKind)

Создает новый объект DateTime, имеющий то же количество тактов, что и заданный объект DateTime, но предназначенный для использования либо с местным временем, стандартом UTC, либо ни тем, ни другим, как задано значением DateTimeKind.

Subtract(DateTime)

Возвращает новый объект TimeSpan, который вычитает из значения этого экземпляра указанную дату и время.

Subtract(TimeSpan)

Возвращает новый объект DateTime, который вычитает из значения этого экземпляра указанную длительность.

ToBinary()

Сериализует текущий объект DateTime в 64-разрядное двоичное значение, которое может использоваться в дальнейшем для воссоздания объекта DateTime.

ToFileTime()

Преобразует значение текущего объекта DateTime во временную характеристику файла Windows.

ToFileTimeUtc()

Преобразует значение текущего объекта DateTime во временную характеристику файла Windows.

ToLocalTime()

Преобразует значение текущего объекта DateTime в местное время.

ToLongDateString()

Преобразует значение текущего объекта DateTime в эквивалентное ему длинное строковое представление даты.

ToLongTimeString()

Преобразует значение текущего объекта DateTime в эквивалентное ему длинное строковое представление времени.

ToOADate()

Преобразует числовое значение этого экземпляра в эквивалентное ему значение даты OLE-автоматизации.

ToShortDateString()

Преобразует значение текущего объекта DateTime в эквивалентное ему короткое строковое представление даты.

ToShortTimeString()

Преобразует значение текущего объекта DateTime в эквивалентное ему короткое строковое представление времени.

ToString()

Преобразует значение текущего объекта DateTime в эквивалентное строковое представление с помощью соглашений о форматировании для текущего языка и региональных параметров.

ToString(IFormatProvider)

Преобразует значение текущего объекта DateTime в эквивалентное ему строковое представление с использованием указанных сведений о форматировании, связанных с языком и региональными параметрами.

ToString(String)

Преобразует значение текущего объекта DateTime в эквивалентное строковое представление с использованием указанного формата и соглашений о форматировании, принятых для текущего языка и региональных параметров.

ToString(String, IFormatProvider)

Преобразует значение текущего объекта DateTime в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях формата для данного языка и региональных параметров.

ToUniversalTime()

Преобразует значение текущего объекта DateTime во время UTC.

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

Пытается отформатировать значение текущего экземпляра даты и времени в указанный диапазон символов.

TryParse(ReadOnlySpan<Char>, DateTime)

Преобразовывает указанный диапазон символов даты и времени в его эквивалент DateTime и возвращает значение, позволяющее определить успешность преобразования.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Пытается проанализировать диапазон символов в значение.

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

Преобразует представление даты и времени в виде диапазона в его эквивалент DateTime, используя указанную информацию о форматировании, связанную с языком и региональными параметрами, и возвращает значение, которое показывает успешность преобразования.

TryParse(String, DateTime)

Преобразовывает указанное строковое представление даты и времени в его эквивалент DateTime и возвращает значение, позволяющее определить успешность преобразования.

TryParse(String, IFormatProvider, DateTime)

Пытается проанализировать строку в значение.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя указанную информацию о форматировании, связанную с языком и региональными параметрами, и возвращает значение, которое показывает успешность преобразования.

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

Преобразует заданное представление диапазона даты и времени в его эквивалент DateTime, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату. Метод возвращает значение, указывающее, успешно ли выполнено преобразование.

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

Преобразовывает указанный диапазон символов даты и времени в его эквивалент DateTime и возвращает значение, позволяющее определить успешность преобразования.

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

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя заданный формат, указанные сведения о форматировании, связанные с языком и региональными параметрами, а также стиль. Формат строкового представления должен полностью соответствовать заданному формату. Метод возвращает значение, указывающее, успешно ли выполнено преобразование.

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

Преобразует заданное строковое представление даты и времени в его эквивалент DateTime, используя заданный массив форматов, указанные сведения о форматировании, связанные с языком и региональными параметрами, и стиль форматирования. Формат представления строки должен полностью соответствовать хотя бы одному заданному формату. Метод возвращает значение, указывающее, успешно ли выполнено преобразование.

Операторы

Addition(DateTime, TimeSpan)

Прибавляет указанный временной интервал к заданной дате и времени, возвращая новую дату и время.

Equality(DateTime, DateTime)

Определяет, равны ли два заданных экземпляра класса DateTime.

GreaterThan(DateTime, DateTime)

Определяет, является ли значение одного заданного объекта DateTime позже другого заданного объекта DateTime.

GreaterThanOrEqual(DateTime, DateTime)

Определяет, представляет ли один заданный DateTime дату и время, которое такое же или позже, чем другое заданное DateTime.

Inequality(DateTime, DateTime)

Определяет, являются ли два заданных экземпляра класса DateTime неравными.

LessThan(DateTime, DateTime)

Определяет, является ли значение одного заданного объекта DateTime раньшим, чем значение другого заданного объекта DateTime.

LessThanOrEqual(DateTime, DateTime)

Определяет, представляет ли один заданный DateTime дату и время, которое такое же или раньше, чем другое заданное DateTime.

Subtraction(DateTime, DateTime)

Вычитает указанную дату и время из другой указанной даты и времени и возвращает временной интервал.

Subtraction(DateTime, TimeSpan)

Вычитает заданный временной интервал из указанной даты и времени и возвращает новую дату и время.

Явные реализации интерфейса

IComparable.CompareTo(Object)

Сравнивает текущий экземпляр с другим объектом того же типа и возвращает целое число, которое показывает, расположен ли текущий экземпляр перед, после или на той же позиции в порядке сортировки, что и другой объект.

IConvertible.GetTypeCode()

Возвращает TypeCode для этого экземпляра.

IConvertible.ToBoolean(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToByte(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToChar(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Возвращает текущий объект DateTime.

IConvertible.ToDecimal(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToDouble(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToInt16(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToInt32(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToInt64(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToSByte(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToSingle(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToType(Type, IFormatProvider)

Преобразует текущий объект DateTime в объект заданного типа.

IConvertible.ToUInt16(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToUInt32(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

IConvertible.ToUInt64(IFormatProvider)

Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Заполняет объект SerializationInfo данными, необходимыми для сериализации текущего объекта DateTime.

Применяется к

Потокобезопасность

Все члены этого типа потокобезопасны. Члены, которые могут изменить состояние экземпляра, в действительности возвращают новый экземпляр, инициализированный новым значением. Как с любым другим типом, чтение и запись общей переменной, которая содержит экземпляр этого типа, должны быть защищены блокировкой для обеспечения потокобезопасности.

См. также раздел