DateTime Struktura

Definicja

Reprezentuje moment w czasie, zwykle wyrażony jako data i godzina dnia.

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
Dziedziczenie
DateTime
Atrybuty
Implementuje

Uwagi

Ważne

Ery w kalendarzach japońskich są oparte na suchem rzeszy i w związku z tym oczekuje się, że zmienią się. Na przykład 1 maja 2019 r. oznaczał początek ery Reiwa w i JapaneseCalendar JapaneseLunisolarCalendar . Taka zmiana ery ma wpływ na wszystkie aplikacje, które używają tych kalendarzy. Aby uzyskać więcej informacji i określić, czy dotyczy to aplikacji, zobacz Obsługa nowej ery w kalendarzu japońskim na platformie .NET. Aby uzyskać informacje na temat testowania aplikacji w Windows w celu zapewnienia ich gotowości na zmianę ery, zobacz Przygotowanie aplikacji na zmianę ery japońskiej. Aby uzyskać informacje o funkcjach na platformie .NET, które obsługują kalendarze z wieloma erami, oraz o najlepszych rozwiązaniach podczas pracy z kalendarzami, które obsługują wiele er, zobacz Praca z erami.

Uwaga

Niektóre przykłady w języku C# w tym artykule są uruchamiane w Try.NET uruchamiać kod i zabaw. Wybierz przycisk Uruchom, aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu możesz go zmodyfikować i uruchomić zmodyfikowany kod, ponownie wybierając pozycję Uruchom. Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub, jeśli kompilacja zakończy się niepowodzeniem, w oknie interaktywnym zostaną wyświetlone wszystkie komunikaty o błędach kompilatora języka C#.

Lokalna strefa czasowa wbudowanego Try.NET i zabaw dla kodu jest Uniwersalny czas koordynowany, czyli UTC. Może to mieć wpływ na zachowanie i dane wyjściowe przykładów ilustrujących typy DateTime , i oraz ich elementy DateTimeOffset TimeZoneInfo członkowskie.

Ten artykuł zawiera kilka przykładów, które używają DateTime typu:

Przykłady inicjowania

Formatowanie DateTime obiektów jako ciągów

Analizowanie ciągów jako DateTime obiektów

DateTime Rozdzielczość

Kultura i kalendarze

Trwałości

Ta sekcja zawiera tematy dotyczące wielu typowych DateTime zastosowań struktury:

Typ DateTime wartości reprezentuje daty i godziny z wartościami od 00:00:00 (północ), 1 stycznia 0001 Anno Domini (Common Era) do 11:59:59 PM, 31 grudnia 9999 A.D. (C.E.) w kalendarzu gregoriańskim.

Wartości czasu są mierzone w 100-nanosekundowych jednostkach nazywanych kleszczami. Konkretna data to liczba kleszczy od 12:00 północy, 1 stycznia 0001 R. (C.E.) w kalendarzu GregorianCalendar . Liczba nie obejmuje znaczników, które zostaną dodane przez sekundy przestępne. Na przykład wartość znaczników 31241376000000000L reprezentuje datę piątek, 01 stycznia 0100 12:00:00 północy. DateTime Wartość jest zawsze wyrażona w kontekście jawnego lub domyślnego kalendarza.

Uwaga

Jeśli pracujesz z wartością znaczników, którą chcesz przekonwertować na inny interwał czasu, taki jak minuty lub sekundy, należy użyć stałej TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinuteTimeSpan.TicksPerSecondlub TimeSpan.TicksPerMillisecond , aby wykonać konwersję. Aby na przykład dodać liczbę sekund reprezentowanych przez określoną liczbę znaczników do Second składnika DateTime wartości, możesz użyć wyrażenia dateValue.Second + nTicks/Timespan.TicksPerSecond.

Źródło dla całego zestawu przykładów można wyświetlić w tym artykule w języku Visual Basic, F# lub C# z repozytorium dokumentacji w witrynie GitHub.

Uwaga

Alternatywą dla DateTime struktury pracy z wartościami daty i godziny w określonych strefach czasowych jest DateTimeOffset struktura. Struktura DateTimeOffset przechowuje informacje o dacie i godzinie w polu prywatnym DateTime oraz liczbę minut, o które ta data i godzina różnią się od czasu UTC w polu prywatnym Int16 . Dzięki temu wartość może DateTimeOffset odzwierciedlać czas w określonej strefie czasowej, natomiast DateTime wartość może jednoznacznie odzwierciedlać tylko czas UTC i czas lokalnej strefy czasowej. Aby zapoznać się z omówieniem, kiedy należy użyć struktury lub DateTimeOffset struktury podczas pracy z wartościami daty i godziny, zobacz Wybieranie między wartościami datetime, DateTimeOffset, TimeSpan i TimeZoneInfo.DateTime

Inicjowanie obiektu DateTime

Wartość początkową można przypisać do nowej DateTime wartości na wiele różnych sposobów:

  • Wywoływanie konstruktora , który określa argumenty dla wartości, lub użyj niejawnego konstruktora bez parametrów.
  • Przypisywanie elementu DateTime do wartości zwracanej właściwości lub metody.
  • Analizowanie DateTime wartości z reprezentacji ciągu.
  • Używanie funkcji języka specyficznych dla języka Visual Basic do utworzenia wystąpienia elementu DateTime.

Poniższe fragmenty kodu pokazują przykłady każdego z nich:

Wywoływanie konstruktorów

Należy wywołać dowolne przeciążenia DateTime konstruktora, które określają elementy wartości daty i godziny (takie jak rok, miesiąc i dzień lub liczba kleszczy). Poniższy kod tworzy określoną datę przy użyciu konstruktora określającego DateTime rok, miesiąc, dzień, godzinę, minutę i sekundę.

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}"

Niejawny konstruktor bez parametrów struktury jest wywoływany DateTime , gdy ma zostać DateTime zainicjowany do jego wartości domyślnej. (Aby uzyskać szczegółowe informacje na temat niejawnego konstruktora bez parametrów typu wartości, zobacz Typy wartości). Niektóre kompilatory obsługują również deklarowanie DateTime wartości bez jawnego przypisania do niej wartości. Utworzenie wartości bez jawnej inicjalizacji powoduje również wyświetlenie wartości domyślnej. Poniższy przykład ilustruje DateTime niejawny konstruktor bez parametrów w językach C# i Visual Basic, a także deklarację DateTime bez przypisania w 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}"
Przypisywanie obliczonej wartości

Obiekt można przypisać DateTime wartość daty i godziny zwróconej przez właściwość lub metodę. Poniższy przykład przypisuje bieżącą datę i godzinę, bieżącą datę i godzinę uniwersalnego czasu koordynowanego (UTC) oraz bieżącą datę do trzech nowych DateTime zmiennych.

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
Analizowanie ciągu reprezentującego wartość DateTime

Metody Parse, ParseExact, TryParsei TryParseExact konwertują ciąg na równoważną wartość daty i godziny. W poniższych przykładach użyto Parse metod i ParseExact , aby przeanalizować ciąg i przekonwertować go na DateTime wartość. Drugi format używa formularza obsługiwanego przez standard ISO 8601 dla reprezentującego datę i godzinę w formacie ciągu. Ta standardowa reprezentacja jest często używana do transferu informacji o dacie w usługach internetowych.

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)

Metody TryParse i TryParseExact wskazują, czy ciąg jest prawidłową reprezentacją DateTime wartości, a jeśli jest, wykonuje konwersję.

Składnia specyficzna dla języka dla języka Visual Basic

Poniższa instrukcja języka Visual Basic inicjuje nową DateTime wartość.

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

Wartości datetime i ich reprezentacje ciągów

Wewnętrznie wszystkie DateTime wartości są reprezentowane jako liczba kleszczy (liczba 100-nanosekundowych interwałów), które upłynęły od 12:00:00 północy, 1 stycznia 0001. Wartość rzeczywista DateTime jest niezależna od sposobu wyświetlania tej wartości. Wygląd DateTime wartości jest wynikiem operacji formatowania, która konwertuje wartość na jej reprezentację ciągu.

Wygląd wartości daty i godziny zależy od kultury, standardów międzynarodowych, wymagań aplikacji i preferencji osobistych. Struktura DateTime zapewnia elastyczność formatowania wartości daty i godziny przez przeciążenia elementu ToString. Metoda domyślna DateTime.ToString() zwraca reprezentację ciągu wartości daty i godziny przy użyciu wzorca daty i godziny krótkiej bieżącej kultury. W poniższym przykładzie użyto metody domyślnej DateTime.ToString() . Wyświetla datę i godzinę przy użyciu wzorca daty krótkiej i godziny długiej dla bieżącej kultury. Kultura en-US jest bieżącą kulturą na komputerze, na którym uruchomiono przykład.

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

Może być konieczne sformatowanie dat w określonej kulturze w celu obsługi scenariuszy internetowych, w których serwer może znajdować się w innej kulturze niż klient. Należy określić kulturę przy użyciu DateTime.ToString(IFormatProvider) metody , aby utworzyć reprezentację daty krótkiej i długiej czasu w określonej kulturze. W poniższym przykładzie użyto DateTime.ToString(IFormatProvider) metody , aby wyświetlić datę i godzinę przy użyciu wzorca daty krótkiej i długiej dla kultury 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

Inne aplikacje mogą wymagać różnych reprezentacji ciągów daty. Metoda DateTime.ToString(String) zwraca reprezentację ciągu zdefiniowaną przez specyfikator formatu standardowego lub niestandardowego przy użyciu konwencji formatowania bieżącej kultury. W poniższym przykładzie użyto DateTime.ToString(String) metody , aby wyświetlić pełny wzorzec daty i godziny dla kultury en-US, bieżącą kulturę na komputerze, na którym został uruchomiony przykład.

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

Na koniec można określić zarówno kulturę, jak i format przy użyciu DateTime.ToString(String, IFormatProvider) metody . W poniższym przykładzie DateTime.ToString(String, IFormatProvider) użyto metody , aby wyświetlić pełny wzorzec daty i godziny dla kultury 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

Przeciążenie DateTime.ToString(String) może być również używane z ciągiem formatu niestandardowego w celu określenia innych formatów. W poniższym przykładzie pokazano, jak sformatować ciąg przy użyciu standardowego formatu ISO 8601 często używanego dla usług internetowych. Format Iso 8601 nie ma odpowiedniego standardowego ciągu formatu.

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

Aby uzyskać więcej informacji na temat formatowania DateTime wartości, zobacz Standardowe ciągi formatu daty i godziny oraz niestandardowe ciągi formatu daty i godziny.

Analizowanie wartości datetime z ciągów

Analizowanie konwertuje reprezentację ciągu daty i godziny na DateTime wartość. Zazwyczaj ciągi daty i godziny mają dwa różne zastosowania w aplikacjach:

  • Data i godzina zajmują różne formy i odzwierciedlają konwencje bieżącej kultury lub konkretnej kultury. Na przykład aplikacja zezwala użytkownikowi, którego bieżąca kultura jest en-US, aby wprowadzić wartość daty jako "12/15/2013" lub "15 grudnia 2013". Umożliwia to użytkownikowi, którego bieżąca kultura jest en-gb, aby wprowadzić wartość daty jako "15/12/2013" lub "15 grudnia 2013".

  • Data i godzina są reprezentowane w wstępnie zdefiniowanym formacie. Na przykład aplikacja serializuje datę jako "20130103" niezależnie od kultury, na której działa aplikacja. Aplikacja może wymagać danych wejściowych w formacie daty krótkiej bieżącej kultury.

Metoda or TryParse służy Parse do konwertowania ciągu z jednego z typowych formatów daty i godziny używanych przez kulturę DateTime do wartości. W poniższym przykładzie przedstawiono sposób konwertowania TryParse ciągów dat w różnych formatach specyficznych dla kultury na DateTime wartość. Zmienia on bieżącą kulturę na angielski (Wielka Brytania) i wywołuje GetDateTimeFormats() metodę w celu wygenerowania tablicy ciągów daty i godziny. Następnie przekazuje każdy element w tablicy do TryParse metody . Dane wyjściowe z przykładu pokazują, że metoda analizowania mogła pomyślnie przekonwertować każdą z ciągów daty i godziny specyficznej dla kultury.

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

Metody i TryParseExact służą ParseExact do konwertowania ciągu, który musi być zgodny z określonym formatem lub formatem DateTime wartości. Można określić co najmniej jeden ciąg formatu daty i godziny jako parametr metody analizowania. W poniższym przykładzie TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) użyto metody do konwertowania ciągów, które muszą być w formacie "yyyMdd" lub "HHmmss" do DateTime wartości.

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

Jednym z typowych zastosowań jest ParseExact przekonwertowanie reprezentacji ciągu z usługi internetowej, zwykle w formacie standardowym ISO 8601 . Poniższy kod przedstawia prawidłowy ciąg formatu do użycia:

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}")

Jeśli nie można przeanalizować ciągu, Parse metody i ParseExact zgłaszają wyjątek. Metody TryParse i TryParseExact zwracają wartość wskazującą, czy konwersja zakończyła się powodzeniem Boolean , czy niepowodzeniem. Należy użyć TryParse metod lub TryParseExact w scenariuszach, w których wydajność jest ważna. Operacja analizowania ciągów daty i godziny zwykle ma wysoką szybkość awarii, a obsługa wyjątków jest kosztowna. Użyj tych metod, jeśli ciągi są wprowadzane przez użytkowników lub pochodzą z nieznanego źródła.

Aby uzyskać więcej informacji na temat analizowania wartości daty i godziny, zobacz Analizowanie ciągów daty i godziny.

Wartości typu DateTime

Opisy wartości czasu w typie DateTime są często wyrażane przy użyciu standardu uniwersalnego czasu koordynowanego (UTC). Koordynowany uniwersalny czas jest międzynarodowo rozpoznawaną nazwą Greenwich Mean Time (GMT). Uniwersalny czas koordynowany to czas mierzony o długości geograficznej zero stopni czasu utc. Czas letni nie ma zastosowania do czasu UTC.

Czas lokalny jest względny dla określonej strefy czasowej. Strefa czasowa jest skojarzona z przesunięciem strefy czasowej. Przesunięcie strefy czasowej to przesunięcie strefy czasowej mierzonej w godzinach od punktu początkowego UTC. Ponadto czas lokalny ma wpływ opcjonalnie na czas letni, który dodaje lub odejmuje korektę interwału czasu. Czas lokalny jest obliczany przez dodanie przesunięcia strefy czasowej do czasu UTC i dostosowanie czasu letniego w razie potrzeby. Przesunięcie strefy czasowej w punkcie źródłowym UTC wynosi zero.

Czas UTC jest odpowiedni dla obliczeń, porównań i przechowywania dat i godziny w plikach. Czas lokalny jest odpowiedni do wyświetlania w interfejsach użytkownika aplikacji klasycznych. Aplikacje obsługujące strefę czasową (takie jak wiele aplikacji internetowych) muszą również współpracować z wieloma innymi strefami czasowymi.

Kind Jeśli właściwość DateTime obiektu to DateTimeKind.Unspecified, nie jest określona, czy reprezentowany czas to czas lokalny, czas UTC, czy czas w innej strefie czasowej.

Rozpoznawanie daty/godziny

Uwaga

Alternatywą dla wykonywania arytmetyki daty i godziny dla DateTime wartości w celu pomiaru czasu, który upłynął, można użyć Stopwatch klasy .

Właściwość Ticks wyraża wartości daty i godziny w jednostkach o wartości dziesiątej miliona sekundy. Właściwość Millisecond zwraca tysięczne części sekundy w wartości daty i godziny. Używanie powtarzających się wywołań do DateTime.Now właściwości w celu pomiaru czasu, który upłynął, zależy od zegara systemowego. Zegar systemowy w systemach Windows 7 i Windows 8 ma rozdzielczość około 15 milisekund. Ta rozdzielczość wpływa na małe interwały czasowe mniejsze niż 100 milisekund.

Poniższy przykład ilustruje zależność bieżących wartości daty i godziny od rozdzielczości zegara systemowego. W przykładzie pętla zewnętrzna powtarza się 20 razy, a pętla wewnętrzna służy do opóźnienia pętli zewnętrznej. Jeśli wartość zewnętrznego licznika pętli wynosi 10, wywołanie Thread.Sleep metody wprowadza pięć milisekund opóźnienia. W poniższym przykładzie pokazano liczbę milisekund zwróconych przez DateTime.Now.Milliseconds właściwość zmienia się tylko po wywołaniu metody Thread.Sleep.

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

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.
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

Operacje typu DateTime

Obliczenie używające DateTime struktury, takiej jak Add lub Subtract, nie modyfikuje wartości struktury. Zamiast tego obliczenie zwraca nową DateTime strukturę, której wartość jest wynikiem obliczenia.

Operacje konwersji między strefami czasowymi (na przykład między czasem UTC a czasem lokalnym lub między jedną strefą czasową a drugą) biorą pod uwagę czas letni, ale operacje arytmetyczne i porównania nie.

Sama DateTime struktura oferuje ograniczoną obsługę konwersji z jednej strefy czasowej na inną. Możesz użyć metody , aby przekonwertować czas UTC na lokalny lub użyć metody do konwersji z czasu lokalnego ToLocalTime ToUniversalTime na UTC. Jednak w klasie jest dostępny pełny zestaw metod konwersji strefy czasowej TimeZoneInfo . Czas można przekonwertować w dowolnej ze stref czasowych na czas w dowolnej innej strefie czasowej przy użyciu tych metod.

Obliczenia i porównania DateTime obiektów mają znaczenie tylko wtedy, gdy obiekty reprezentują czasy w tej samej strefie czasowej. Można użyć TimeZoneInfo obiektu do reprezentowania DateTime strefy czasowej wartości, chociaż te dwa są luźno powiązane. DateTime Obiekt nie ma właściwości, która zwraca obiekt reprezentujący strefę czasową tej wartości daty i godziny. Właściwość Kind wskazuje, czy DateTime reprezentuje utc, czas lokalny lub jest nieokreślony. W aplikacji obsługującej strefy czasowej należy opierać się na pewnym mechanizmie zewnętrznym, aby określić strefę czasową, w której DateTime został utworzony obiekt. Można użyć struktury, która opakowuje zarówno DateTime wartość, jak i TimeZoneInfo obiekt reprezentujący DateTime strefę czasową wartości. Aby uzyskać szczegółowe informacje na temat używania czasu UTC w obliczeniach i porównaniach z wartościami DateTime , zobacz Wykonywanie operacji arytmetycznych z datami i godzinami.

Każdy DateTime element członkowski niejawnie używa kalendarza gregoriańskiego do wykonania operacji. Wyjątki to metody, które niejawnie określają kalendarz. Obejmują one konstruktory, które określają kalendarz i metody z parametrem pochodzącym z IFormatProviderklasy , na przykład System.Globalization.DateTimeFormatInfo.

Operacje według członków DateTime typu uwzględniają szczegóły, takie jak lata przestępne i liczba dni w miesiącu.

Wartości daty/godziny i kalendarze

Biblioteka klas .NET Framework zawiera wiele klas kalendarza, z których wszystkie pochodzą z Calendar klasy. Są to:

Ważne

Ery w kalendarzach japońskich są oparte na suchem rzeszy i w związku z tym oczekuje się, że zmienią się. Na przykład 1 maja 2019 r. oznaczał początek ery Reiwa w i JapaneseCalendar JapaneseLunisolarCalendar . Taka zmiana ery ma wpływ na wszystkie aplikacje, które używają tych kalendarzy. Aby uzyskać więcej informacji i określić, czy dotyczy to aplikacji, zobacz Obsługa nowej ery w kalendarzu japońskim na platformie .NET. Aby uzyskać informacje na temat testowania aplikacji w Windows w celu zapewnienia ich gotowości na zmianę ery, zobacz Przygotowanie aplikacji na zmianę ery japońskiej. Aby uzyskać informacje o funkcjach na platformie .NET, które obsługują kalendarze z wieloma erami, oraz o najlepszych rozwiązaniach podczas pracy z kalendarzami, które obsługują wiele er, zobacz Praca z erami.

Każda kultura używa domyślnego kalendarza zdefiniowanego przez jego właściwość tylko do CultureInfo.Calendar odczytu. Każda kultura może obsługiwać co najmniej jeden kalendarz zdefiniowany przez jego właściwość tylko do CultureInfo.OptionalCalendars odczytu. Kalendarz używany obecnie przez określony CultureInfo obiekt jest definiowany przez jego DateTimeFormatInfo.Calendar właściwość. Musi to być jeden z kalendarzy znalezionych w tablicy CultureInfo.OptionalCalendars .

Bieżący kalendarz kultury jest używany we wszystkich operacjach formatowania dla tej kultury. Na przykład domyślnym kalendarzem tajskiej kultury buddyjskiej jest tajski kalendarz ery buddyjskiej, który jest reprezentowany przez klasę ThaiBuddhistCalendar . CultureInfo Gdy obiekt reprezentujący tajlandzką kulturę buddyjską jest używany w operacji formatowania daty i godziny, kalendarz tajskiej ery buddyjskiej jest używany domyślnie. Kalendarz gregoriański jest używany tylko wtedy, gdy właściwość kultury zostanie zmieniona DateTimeFormatInfo.Calendar , jak pokazano w poniższym przykładzie:

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

Bieżący kalendarz kultury jest również używany we wszystkich operacjach analizy dla tej kultury, jak pokazano w poniższym przykładzie.

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

Utworzenie wystąpienia DateTime wartości przy użyciu elementów daty i godziny (liczba roku, miesiąca i dnia) określonego kalendarza przez wywołanie konstruktora DateTime zawierającego calendar parametr i przekazanie go obiektu reprezentującego Calendar ten kalendarz. W poniższym przykładzie użyto elementów daty i godziny z ThaiBuddhistCalendar kalendarza.

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 konstruktory, które nie zawierają parametru calendar , zakładają, że elementy daty i godziny są wyrażone jako jednostki w kalendarzu gregoriańskim.

Wszystkie inne DateTime właściwości i metody używają kalendarza gregoriańskiego. Na przykład DateTime.Year właściwość zwraca rok w kalendarzu gregoriańskim, a DateTime.IsLeapYear(Int32) metoda zakłada, że year parametr jest rokiem w kalendarzu gregoriańskim. Każdy DateTime element członkowski korzystający z kalendarza gregoriańskiego ma odpowiedni element członkowski Calendar klasy używającej określonego kalendarza. Na przykład Calendar.GetYear metoda zwraca rok w określonym kalendarzu, a Calendar.IsLeapYear metoda interpretuje year parametr jako numer roku w określonym kalendarzu. W poniższym przykładzie użyto zarówno elementów członkowskich, jak DateTime i odpowiadających jej składowych ThaiBuddhistCalendar klasy.

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

Struktura DateTime zawiera właściwość zwracającą DayOfWeek dzień tygodnia w kalendarzu gregoriańskim. Nie zawiera on elementu członkowskiego, który umożliwia pobranie numeru tygodnia roku. Aby pobrać tydzień roku, wywołaj metodę poszczególnych kalendarzy Calendar.GetWeekOfYear . Poniższy przykład stanowi ilustrację.

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

Aby uzyskać więcej informacji na temat dat i kalendarzy, zobacz Praca z kalendarzami.

Utrwalanie wartości daty/godziny

Wartości można utrwalać DateTime na cztery sposoby:

Należy upewnić się, że procedura przywracania DateTime wartości nie powoduje utraty danych lub zgłaszania wyjątku niezależnie od wybranej techniki. DateTime wartości powinny być zaokrąglone. Oznacza to, że oryginalna wartość i przywrócona wartość powinny być takie same. A jeśli oryginalna DateTime wartość reprezentuje pojedynczą chwilę czasu, powinna identyfikować ten sam moment, kiedy zostanie przywrócona.

Utrwalanie wartości jako ciągów

Aby pomyślnie przywrócić DateTime wartości utrwalone jako ciągi, postępuj zgodnie z następującymi regułami:

  • Przyjmij te same założenia dotyczące formatowania specyficznego dla kultury podczas przywracania ciągu, jak podczas jego utrwalania. Aby upewnić się, że ciąg można przywrócić w systemie, którego bieżąca kultura różni się od kultury systemu, na którym został zapisany, wywołaj ToString przeciążenie, aby zapisać ciąg przy użyciu konwencji niezmiennej kultury. Wywołaj przeciążenie Parse(String, IFormatProvider, DateTimeStyles) lub TryParse(String, IFormatProvider, DateTimeStyles, DateTime) , aby przywrócić ciąg przy użyciu konwencji niezmiennej kultury. Nigdy nie używaj ToString()przeciążeń , Parse(String)lub TryParse(String, DateTime) , które używają konwencji bieżącej kultury.

  • Jeśli data reprezentuje jeden moment czasu, upewnij się, że reprezentuje ten sam moment w czasie, gdy zostanie przywrócony, nawet w innej strefie czasowej. Przed zapisaniem wartości przekonwertuj DateTime wartość na uniwersalny czas koordynowany (UTC). Można również serializować wartość wraz z informacjami o strefie czasowej. Aby uzyskać więcej informacji na temat tego podejścia, zobacz Serializowanie danych daty/godziny i strefy czasowej.

Najczęstszym błędem występującym podczas utrwalania DateTime wartości jako ciągów jest poleganie na konwencjach formatowania domyślnej lub bieżącej kultury. Występują problemy, jeśli bieżąca kultura jest inna podczas zapisywania i przywracania ciągów. Poniższy przykład ilustruje te problemy. Zapisuje pięć dat przy użyciu konwencji formatowania bieżącej kultury, co w tym przypadku jest angielski (Stany Zjednoczone). Przywraca daty przy użyciu konwencji formatowania innej kultury, która w tym przypadku jest angielska (Wielka Brytania). Ponieważ konwencje formatowania obu kultur są różne, nie można przywrócić dwóch dat, a pozostałe trzy daty są interpretowane niepoprawnie. Ponadto jeśli oryginalne wartości daty i godziny reprezentują pojedyncze momenty w czasie, przywrócone czasy są niepoprawne, ponieważ informacje o strefie czasowej zostaną utracone.

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

Aby pomyślnie zaokrąglić wartości, DateTime wykonaj następujące kroki:

  1. Jeśli wartości reprezentują pojedyncze momenty czasu, przekonwertuj je z czasu lokalnego na czas UTC, wywołując metodę ToUniversalTime .
  2. Przekonwertuj daty na ich reprezentacje ciągów, wywołując ToString(String, IFormatProvider) przeciążenie lub String.Format(IFormatProvider, String, Object[]) . Użyj konwencji formatowania niezmiennej kultury, określając CultureInfo.InvariantCulture jako provider argument. Określ, że wartość powinna być zaokrąglana przy użyciu standardowego ciągu formatu "O" lub "R".

Aby przywrócić utrwalone DateTime wartości bez utraty danych, wykonaj następujące kroki:

  1. Przeanalizuj dane przez wywołanie przeciążenia ParseExact lub TryParseExact . Określ CultureInfo.InvariantCulture jako provider argument i użyj tego samego standardowego ciągu formatu, który został użyty dla argumentu format podczas konwersji. Uwzględnij DateTimeStyles.RoundtripKind wartość w argumencie styles .
  2. DateTime Jeśli wartości reprezentują pojedyncze momenty w czasie, wywołaj metodę ToLocalTime , aby przekonwertować przeanalizowaną datę z czasu UTC na czas lokalny.

W poniższym przykładzie użyto niezmiennej kultury i standardowego ciągu formatu "O", aby upewnić się, że DateTime wartości zapisane i przywrócone reprezentują ten sam moment w czasie niezależnie od systemu, kultury lub strefy czasowej systemów źródłowych i docelowych.

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...
Utrwalanie wartości jako liczb całkowitych

Możesz utrwały datę i godzinę jako wartość reprezentującą Int64 liczbę znaczników. W takim przypadku nie trzeba brać pod uwagę kultury systemów DateTime , na których wartości są utrwalane i przywracane.

Aby utrwały DateTime wartość jako liczbę całkowitą:

  • DateTime Jeśli wartości reprezentują pojedyncze chwile w czasie, przekonwertuj je na czas UTC, wywołując metodę ToUniversalTime .
  • Pobierz liczbę kleszczy reprezentowanych przez DateTime wartość z jego Ticks właściwości.

Aby przywrócić DateTime wartość, która została utrwalone jako liczba całkowita:

  1. Utwórz wystąpienie nowego DateTime obiektu, przekazując Int64 wartość do konstruktora DateTime(Int64) .
  2. DateTime Jeśli wartość reprezentuje jeden moment w czasie, przekonwertuj ją z czasu UTC na czas lokalny, wywołując metodę ToLocalTime .

Poniższy przykład utrzymuje tablicę DateTime wartości jako liczby całkowite w systemie w strefie czasowej Pacyfik USA. Przywraca go w systemie w strefie UTC. Plik zawierający liczby całkowite zawiera Int32 wartość, która wskazuje całkowitą liczbę Int64 wartości, które natychmiast po niej następują.

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

Serializowanie wartości datetime

Wartości można utrwalać DateTime za pomocą serializacji do strumienia lub pliku, a następnie przywrócić je za pomocą deserializacji. DateTime dane są serializowane w określonym formacie obiektu. Obiekty są przywracane podczas deserializacji. Formatator lub serializator, taki jak XmlSerializer lub BinaryFormatter, obsługuje proces serializacji i deserializacji. Aby uzyskać więcej informacji na temat serializacji i typów serializacji obsługiwanych przez .NET Framework, zobacz Serializacja.

W poniższym przykładzie użyto XmlSerializer klasy do serializacji i deserializacji DateTime wartości. Wartości reprezentują wszystkie dni roku przestępne w XXI wieku. Dane wyjściowe reprezentują wynik, jeśli przykład jest uruchamiany w systemie, którego bieżąca kultura to Angielski (Wielka Brytania). Ponieważ sam obiekt został zdeserializowany DateTime , kod nie musi obsługiwać różnic kulturowych w formatach daty i godziny.

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

Poprzedni przykład nie zawiera informacji o czasie. DateTime Jeśli wartość reprezentuje moment w czasie i jest wyrażona jako czas lokalny, przekonwertuj ją z czasu lokalnego na UTC przed serializacją, wywołując metodę ToUniversalTime . Po deserializacji przekonwertuj ją z czasu UTC na czas lokalny, wywołując metodę ToLocalTime . W poniższym przykładzie użyto BinaryFormatter klasy do serializacji DateTime danych w systemie w strefie czasowej Pacyfik (pacyficzny) i deserializacji ich w systemie w strefie Standardowa w USA.

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

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

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

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

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

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

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

Serializowanie danych daty/godziny i strefy czasowej

W poprzednich przykładach przyjęto założenie, że DateTime wartości są wyrażane jako czasy lokalne. Kod przekonwertował wartości między czasem UTC a czasem lokalnym, aby odzwierciedlały ten sam moment w czasie w systemach źródłowych i docelowych. DateTime wartości mogą również odzwierciedlać momenty w czasie w strefie czasowej innej niż lokalna i UTC. DateTime Ponieważ struktura nie uwzględnia strefy czasowej, należy serializować zarówno wartość, jak DateTime i TimeZoneInfo obiekt reprezentujący jego strefę czasową. Utwórz typ, którego pola zawierają zarówno wartość, jak DateTime i jej strefę czasową. W poniższym przykładzie zdefiniowano DateWithTimeZone strukturę.

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

Ważne

Struktura DateWithTimeZone jest używana w dwóch następnych przykładach, które serializują i deserializują tablicę DateWithTimeZone obiektów. Źródło dla całego zestawu przykładów można wyświetlić w tym artykule w języku Visual Basic, F# lub C# z repozytorium dokumentacji w witrynie GitHub.

Korzystając ze DateWithTimeZone struktury, można następnie utrwalać datę i godzinę wraz z informacjami o strefie czasowej. W poniższym przykładzie użyto BinaryFormatter klasy do serializacji tablicy DateWithTimeZone obiektów.

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

W poniższym przykładzie metoda jest następnie wywoływana BinaryFormatter.Deserialize w celu deserializacji.

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 a TimeSpan

Typy DateTime wartości i TimeSpan różnią się tym, że element DateTime reprezentuje moment w czasie, podczas gdy TimeSpan reprezentuje przedział czasu. Można odjąć jedno wystąpienie DateTime z innego, aby uzyskać TimeSpan obiekt reprezentujący przedział czasu między nimi. Możesz też dodać wynik dodatni TimeSpan do bieżącego DateTime , aby uzyskać wartość reprezentującą DateTime przyszłą datę.

Możesz dodać lub odjąć interwał czasu z DateTime obiektu. Interwały czasu mogą być ujemne lub dodatnie i mogą być wyrażone w jednostkach, takich jak znaczniki, sekundy lub jako TimeSpan obiekt.

Porównywanie równości w granicach tolerancji

Porównania równości dla DateTime wartości są dokładne. Oznacza to, że dwie wartości muszą być wyrażone jako ta sama liczba znaczników, które mają być traktowane jako równe. Ta precyzja jest często niepotrzebna, a nawet niepoprawna dla wielu aplikacji. Często chcesz sprawdzić, czy DateTime obiekty są w przybliżeniu równe.

W poniższym przykładzie pokazano, jak porównać mniej więcej równoważne DateTime wartości. Akceptuje niewielki margines różnicy podczas deklarowania ich równości.

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

Uwagi dotyczące współdziałania COM

DateTime Wartość, która jest przenoszona do aplikacji COM, a następnie jest przenoszona z powrotem do aplikacji zarządzanej, mówi się o podróży okrężnej. DateTime Jednak wartość określająca tylko czas nie jest zaokrąglana, jak można się spodziewać.

Jeśli w obie strony jest tylko godzina, taka jak 15:00, ostateczna data i godzina to 30 grudnia 1899 R.E. o 15:00, zamiast stycznia, 1, 0001 C.E. o 15:00 .NET Framework i COM zakładają datę domyślną, gdy określono tylko godzinę. Jednak system COM zakłada datę bazową 30 grudnia 1899 R., podczas gdy .NET Framework zakłada datę bazową 1 stycznia 0001 R.E.

Gdy tylko czas jest przekazywany z .NET Framework do MODELU COM, wykonywane jest specjalne przetwarzanie, które konwertuje czas na format używany przez com. Gdy tylko czas jest przekazywany z COM do .NET Framework, nie wykonuje się specjalnego przetwarzania, ponieważ spowodowałoby to uszkodzenie uzasadnionych dat i godzin w dniu lub przed 30 grudnia 1899 r. Jeśli data rozpoczyna się od modelu COM, .NET Framework i COM zachowają datę.

Zachowanie .NET Framework i COM oznacza, że jeśli aplikacja zaokrągla czasDateTime, który określa tylko godzinę, aplikacja musi pamiętać o zmodyfikowaniu lub zignorowaniu błędnej daty z obiektu końcowegoDateTime.

Konstruktory

DateTime(Int32, Int32, Int32)

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca i dnia.

DateTime(Int32, Int32, Int32, Calendar)

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca i dnia dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty i sekundy.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty i sekundy dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy i koordynowanego czasu uniwersalnego (UTC) lub czasu lokalnego.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy i milisekundy.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy i milisekund dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego dla określonego kalendarza.

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

Inicjuje DateTime nowe wystąpienie struktury do określonego roku, miesiąca, dnia, godziny, minuty, sekundy, milisekund i uniwersalnego czasu koordynowanego (UTC) lub czasu lokalnego dla określonego kalendarza.

DateTime(Int64)

Inicjuje DateTime nowe wystąpienie struktury do określonej liczby kleszczy.

DateTime(Int64, DateTimeKind)

Inicjuje DateTime nowe wystąpienie struktury na określoną liczbę kleszczy i koordynowany czas uniwersalny (UTC) lub czas lokalny.

Pola

MaxValue

Reprezentuje największą możliwą wartość .DateTime To pole jest tylko do odczytu.

MinValue

Reprezentuje najmniejszą możliwą wartość .DateTime To pole jest tylko do odczytu.

UnixEpoch

Wartość tej stałej jest równoważna 00:00:00.0000000 UTC, 1 stycznia 1970 r. w kalendarzu gregoriańskim. UnixEpoch definiuje punkt w czasie, gdy czas systemu Unix jest równy 0.

Właściwości

Date

Pobiera składnik daty tego wystąpienia.

Day

Pobiera dzień miesiąca reprezentowany przez to wystąpienie.

DayOfWeek

Pobiera dzień tygodnia reprezentowany przez to wystąpienie.

DayOfYear

Pobiera dzień roku reprezentowany przez to wystąpienie.

Hour

Pobiera składnik godziny daty reprezentowanej przez to wystąpienie.

Kind

Pobiera wartość wskazującą, czy czas reprezentowany przez to wystąpienie jest oparty na czasie lokalnym, uniwersalnym czasie koordynowanym (UTC), czy też na żadnym z nich.

Microsecond

Składnik mikrosekund, wyrażony jako wartość z zakresu od 0 do 999.

Millisecond

Pobiera składnik milisekund daty reprezentowanej przez to wystąpienie.

Minute

Pobiera składnik minuty daty reprezentowanej przez to wystąpienie.

Month

Pobiera składnik miesiąca daty reprezentowanej przez to wystąpienie.

Nanosecond

Składnik nanosekund, wyrażony jako wartość z zakresu od 0 do 900 (w przyrostach 100 nanosekund).

Now

Pobiera obiekt ustawiony na bieżącą DateTime datę i godzinę na tym komputerze, wyrażony jako czas lokalny.

Second

Pobiera składnik sekund daty reprezentowanej przez to wystąpienie.

Ticks

Pobiera liczbę znaczników reprezentujących datę i godzinę tego wystąpienia.

TimeOfDay

Pobiera godzinę dnia dla tego wystąpienia.

Today

Pobiera bieżącą datę.

UtcNow

Pobiera obiekt ustawiony na bieżącą DateTime datę i godzinę na tym komputerze, wyrażony jako uniwersalny czas koordynowany (UTC).

Year

Pobiera składnik roku daty reprezentowanej przez to wystąpienie.

Metody

Add(TimeSpan)

Zwraca nowy DateTime element, który dodaje wartość określonego TimeSpan do wartości tego wystąpienia.

AddDays(Double)

Zwraca nową, DateTime która dodaje określoną liczbę dni do wartości tego wystąpienia.

AddHours(Double)

Zwraca nową, DateTime która dodaje określoną liczbę godzin do wartości tego wystąpienia.

AddMicroseconds(Double)

Zwraca nową, DateTime która dodaje określoną liczbę mikrosekund do wartości tego wystąpienia.

AddMilliseconds(Double)

Zwraca nową, DateTime która dodaje określoną liczbę milisekund do wartości tego wystąpienia.

AddMinutes(Double)

Zwraca nową, DateTime która dodaje określoną liczbę minut do wartości tego wystąpienia.

AddMonths(Int32)

Zwraca nową, DateTime która dodaje określoną liczbę miesięcy do wartości tego wystąpienia.

AddSeconds(Double)

Zwraca nową, DateTime która dodaje określoną liczbę sekund do wartości tego wystąpienia.

AddTicks(Int64)

Zwraca nowy DateTime element, który dodaje określoną liczbę znaczników do wartości tego wystąpienia.

AddYears(Int32)

Zwraca nowy DateTime element, który dodaje określoną liczbę lat do wartości tego wystąpienia.

Compare(DateTime, DateTime)

Porównuje dwa wystąpienia DateTime i zwraca liczbę całkowitą, która wskazuje, czy pierwsze wystąpienie jest wcześniejsze niż, takie same jak, czy nowsze niż drugie wystąpienie.

CompareTo(DateTime)

Porównuje wartość tego wystąpienia z określoną DateTime wartością i zwraca liczbę całkowitą, która wskazuje, czy to wystąpienie jest wcześniejsze niż, takie same jak, czy nowsze niż określona DateTime wartość.

CompareTo(Object)

Porównuje wartość tego wystąpienia z określonym obiektem, który zawiera określoną DateTime wartość, i zwraca liczbę całkowitą, która wskazuje, czy to wystąpienie jest wcześniejsze niż, takie same jak lub nowsze niż określona DateTime wartość.

DaysInMonth(Int32, Int32)

Zwraca liczbę dni w określonym miesiącu i roku.

Equals(DateTime)

Zwraca wartość wskazującą, czy wartość tego wystąpienia jest równa wartości określonego DateTime wystąpienia.

Equals(DateTime, DateTime)

Zwraca wartość wskazującą, czy dwa DateTime wystąpienia mają tę samą wartość daty i godziny.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

FromBinary(Int64)

Deserializuje 64-bitową wartość binarną i ponownie tworzy oryginalny obiekt serializowany DateTime .

FromFileTime(Int64)

Konwertuje określony czas pliku systemu Windows na równoważny czas lokalny.

FromFileTimeUtc(Int64)

Konwertuje określony czas pliku systemu Windows na równoważny czas UTC.

FromOADate(Double)

DateTime Zwraca odpowiednik określonej daty automatyzacji OLE.

GetDateTimeFormats()

Konwertuje wartość tego wystąpienia na wszystkie reprezentacje ciągów obsługiwane przez standardowe specyfikatory formatu daty i godziny.

GetDateTimeFormats(Char)

Konwertuje wartość tego wystąpienia na wszystkie reprezentacje ciągów obsługiwane przez określony standardowy specyfikator formatu daty i godziny.

GetDateTimeFormats(Char, IFormatProvider)

Konwertuje wartość tego wystąpienia na wszystkie reprezentacje ciągów obsługiwane przez określony standardowy specyfikator formatu daty i godziny oraz informacje o formatowaniu specyficznym dla kultury.

GetDateTimeFormats(IFormatProvider)

Konwertuje wartość tego wystąpienia na wszystkie reprezentacje ciągów obsługiwane przez standardowe specyfikatory formatu daty i godziny oraz określone informacje dotyczące formatowania specyficzne dla kultury.

GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.

GetTypeCode()

Zwraca wartość TypeCode dla typu DateTimewartości .

IsDaylightSavingTime()

Wskazuje, czy to wystąpienie obiektu DateTime znajduje się w zakresie czasu letniego dla bieżącej strefy czasowej.

IsLeapYear(Int32)

Zwraca wskazanie, czy określony rok jest rokiem przestępnym.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizuje zakres znaków w wartości.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Konwertuje zakres pamięci, który zawiera reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

Parse(String)

Konwertuje reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu konwencji bieżącej kultury.

Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury.

Parse(String, IFormatProvider, DateTimeStyles)

Konwertuje reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o formacie specyficznym dla kultury i stylu formatowania.

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

Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.

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

Konwertuje określoną reprezentację zakresu daty i godziny na jej DateTime odpowiednik przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.

ParseExact(String, String, IFormatProvider)

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Konwertuje określoną reprezentację ciągu daty i godziny na jej DateTime odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z określonym formatem dokładnie lub zgłaszany jest wyjątek.

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

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną, DateTime używając określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być zgodny z co najmniej jednym z określonych formatów lub zgłaszanym wyjątkiem.

SpecifyKind(DateTime, DateTimeKind)

Tworzy nowy DateTime obiekt, który ma taką samą liczbę znaczników, jak określony DateTime, ale jest wyznaczony jako czas lokalny, uniwersalny czas koordynowany (UTC) lub żaden z nich, zgodnie z określoną DateTimeKind wartością.

Subtract(DateTime)

Zwraca nowy TimeSpan element, który odejmuje określoną datę i godzinę od wartości tego wystąpienia.

Subtract(TimeSpan)

Zwraca nowy DateTime element, który odejmuje określony czas trwania od wartości tego wystąpienia.

ToBinary()

Serializuje bieżący DateTime obiekt na 64-bitową wartość binarną, która następnie może służyć do ponownego utworzenia DateTime obiektu.

ToFileTime()

Konwertuje wartość bieżącego DateTime obiektu na czas pliku systemu Windows.

ToFileTimeUtc()

Konwertuje wartość bieżącego DateTime obiektu na czas pliku systemu Windows.

ToLocalTime()

Konwertuje wartość bieżącego DateTime obiektu na czas lokalny.

ToLongDateString()

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu daty długiej.

ToLongTimeString()

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu długiego czasu.

ToOADate()

Konwertuje wartość tego wystąpienia na równoważną datę automatyzacji OLE.

ToShortDateString()

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu daty krótkiej.

ToShortTimeString()

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu krótkiego czasu.

ToString()

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu przy użyciu konwencji formatowania bieżącej kultury.

ToString(IFormatProvider)

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.

ToString(String)

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu przy użyciu określonego formatu i konwencji formatowania bieżącej kultury.

ToString(String, IFormatProvider)

Konwertuje wartość bieżącego DateTime obiektu na równoważną reprezentację ciągu przy użyciu informacji o określonym formacie i formacie specyficznym dla kultury.

ToUniversalTime()

Konwertuje wartość bieżącego DateTime obiektu na uniwersalny czas koordynowany (UTC).

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

Próbuje sformatować wartość bieżącego wystąpienia daty/godziny w podanym zakresie znaków.

TryParse(ReadOnlySpan<Char>, DateTime)

Konwertuje określony zakres znaków daty i godziny na odpowiednik DateTime i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Próbuje przeanalizować zakres znaków w wartości.

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

Konwertuje reprezentację zakresu daty i godziny na odpowiednik DateTime przy użyciu określonych informacji o formacie kultury i stylu formatowania oraz zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

TryParse(String, DateTime)

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTime i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

TryParse(String, IFormatProvider, DateTime)

Próbuje przeanalizować ciąg w wartość.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu określonych informacji o formacie kultury i stylu formatowania oraz zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

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

Konwertuje określoną reprezentację zakresu daty i godziny na odpowiednik DateTime przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu. Metoda zwraca wartość wskazującą, czy konwersja powiodła się.

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

Konwertuje określony zakres znaków daty i godziny na odpowiednik DateTime i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

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

Konwertuje określoną reprezentację ciągu daty i godziny na odpowiednik DateTime przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu. Metoda zwraca wartość wskazującą, czy konwersja powiodła się.

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

Konwertuje określoną reprezentację ciągu daty i godziny na równoważną DateTime przy użyciu określonej tablicy formatów, informacji o formacie specyficznym dla kultury i stylu. Format reprezentacji ciągu musi być dokładnie zgodny z co najmniej jednym z określonych formatów. Metoda zwraca wartość wskazującą, czy konwersja powiodła się.

Operatory

Addition(DateTime, TimeSpan)

Dodaje określony interwał czasu do określonej daty i godziny, dając nową datę i godzinę.

Equality(DateTime, DateTime)

Określa, czy dwa określone wystąpienia adresu DateTime są takie same.

GreaterThan(DateTime, DateTime)

Określa, czy określona wartość DateTime jest późniejsza niż określona przez inną.DateTime

GreaterThanOrEqual(DateTime, DateTime)

Określa, czy określona wartość DateTime reprezentuje datę i godzinę, która jest taka sama jak określona lub późniejsza.DateTime

Inequality(DateTime, DateTime)

Określa, czy dwa określone wystąpienia elementu DateTime nie są takie same.

LessThan(DateTime, DateTime)

Określa, czy określona wartość DateTime jest wcześniejsza niż określona przez inną.DateTime

LessThanOrEqual(DateTime, DateTime)

Określa, czy określony element DateTime reprezentuje datę i godzinę, która jest taka sama jak określona lub wcześniejsza niż określona przez inną wartość DateTime.

Subtraction(DateTime, DateTime)

Odejmuje określoną datę i godzinę od innej określonej daty i godziny i zwraca interwał czasu.

Subtraction(DateTime, TimeSpan)

Odejmuje określony interwał czasu od określonej daty i godziny i zwraca nową datę i godzinę.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.

IConvertible.GetTypeCode()

Zwraca wartość TypeCode dla tego wystąpienia.

IConvertible.ToBoolean(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToByte(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToChar(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Zwraca bieżący DateTime obiekt.

IConvertible.ToDecimal(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToDouble(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToInt16(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToInt32(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToInt64(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToSByte(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToSingle(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToType(Type, IFormatProvider)

Konwertuje bieżący DateTime obiekt na obiekt określonego typu.

IConvertible.ToUInt16(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToUInt32(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

IConvertible.ToUInt64(IFormatProvider)

Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo Wypełnia obiekt danymi potrzebnymi do serializacji bieżącego DateTime obiektu.

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.

Zobacz też