Ten artykuł został przetłumaczony przez maszynę. Aby wyświetlić jego treść w języku angielskim, zaznacz pole wyboru Angielski. Możesz też wyświetlić angielski tekst w okienku wyskakującym, przesuwając wskaźnik myszy nad konkretny tekst”.
Tłumaczenie
Angielski

Struktura DateTime

.NET Framework (current version)
 

Data opublikowania: październik 2016

Reprezentuje moment w czasie, zwykle wyrażone jako datę i godzinę.

Aby przejrzeć kod źródłowy .NET Framework dla tego typu, zobacz Reference Source.

Przestrzeń nazw:   System
Zestaw:  mscorlib (w mscorlib.dll)

[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, IConvertible, 
	ISerializable, IComparable<DateTime>, IEquatable<DateTime>

NazwaOpis
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc i dzień.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

Inicjuje nowe wystąpienie DateTime określony rok, miesiąc i dzień w kalendarzu określonej struktury.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, godziny, minuty i sekundy.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, godzinę, minutę i sekundę dla określonego kalendarza.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, dzień, godzinę, minuty, sekundy i uniwersalny czas koordynowany (UTC) lub czasu lokalnego.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, dzień, godzinę, minuty, sekundy i milisekund.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, dzień, godziny, minuty, sekundy i milisekundy dla określonego kalendarza.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, dzień, godzina, minuty, sekundy, milisekund i uniwersalny czas koordynowany (UTC) lub czas lokalny dla określonego kalendarza.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicjuje nowe wystąpienie DateTime struktury określony rok, miesiąc, dzień, godzinę, minuty, sekundy, milisekund i uniwersalny czas koordynowany (UTC) lub czasu lokalnego.

System_CAPS_pubmethodDateTime(Int64)

Inicjuje nowe wystąpienie DateTime struktury do określonej liczby znaczników.

System_CAPS_pubmethodDateTime(Int64, DateTimeKind)

Inicjuje nowe wystąpienie DateTime struktury określoną liczbę znaczników i uniwersalny czas koordynowany (UTC) lub czasu lokalnego.

NazwaOpis
System_CAPS_pubpropertyDate

Pobiera składnik daty tego wystąpienia.

System_CAPS_pubpropertyDay

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

System_CAPS_pubpropertyDayOfWeek

Pobiera dnia tygodnia reprezentowany przez to wystąpienie.

System_CAPS_pubpropertyDayOfYear

Pobiera dzień roku, reprezentowane przez to wystąpienie.

System_CAPS_pubpropertyHour

Pobiera składnik godziny z datę reprezentowaną przez to wystąpienie.

System_CAPS_pubpropertyKind

Pobiera wartość wskazującą, czy godzina reprezentowana przez to wystąpienie jest oparty na czas lokalny, uniwersalny czas koordynowany (UTC) lub nie.

System_CAPS_pubpropertyMillisecond

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

System_CAPS_pubpropertyMinute

Pobiera składnik minuty datę reprezentowaną przez to wystąpienie.

System_CAPS_pubpropertyMonth

Pobiera składnik miesiąca o dacie reprezentowane przez to wystąpienie.

System_CAPS_pubpropertySystem_CAPS_staticNow

Pobiera DateTime obiekt, który jest ustawiona na bieżącą datę i godzinę na tym komputerze, który jest wyrażona jako czas lokalny.

System_CAPS_pubpropertySecond

Pobiera składnik sekund o dacie reprezentowane przez to wystąpienie.

System_CAPS_pubpropertyTicks

Pobiera liczbę znaczników, które reprezentują daty i godziny tego wystąpienia.

System_CAPS_pubpropertyTimeOfDay

Pobiera godzinę dla tego wystąpienia.

System_CAPS_pubpropertySystem_CAPS_staticToday

Pobiera bieżącą datę.

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

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

System_CAPS_pubpropertyYear

Pobiera składnik roku z daty, reprezentowany przez to wystąpienie.

NazwaOpis
System_CAPS_pubmethodAdd(TimeSpan)

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

System_CAPS_pubmethodAddDays(Double)

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

System_CAPS_pubmethodAddHours(Double)

Zwraca nowy DateTime dodaje określoną liczbę godzin na wartość tego wystąpienia.

System_CAPS_pubmethodAddMilliseconds(Double)

Zwraca nowy DateTime dodaje określoną liczbę milisekund do wartość tego wystąpienia.

System_CAPS_pubmethodAddMinutes(Double)

Zwraca nowy DateTime który dodaje określoną liczbę minut wartość tego wystąpienia.

System_CAPS_pubmethodAddMonths(Int32)

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

System_CAPS_pubmethodAddSeconds(Double)

Zwraca nowy DateTime który dodaje określoną liczbę sekund wartość tego wystąpienia.

System_CAPS_pubmethodAddTicks(Int64)

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

System_CAPS_pubmethodAddYears(Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

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

System_CAPS_pubmethodCompareTo(DateTime)

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

System_CAPS_pubmethodCompareTo(Object)

Porównuje wartość tego wystąpienia do określonego obiektu, który zawiera określonego DateTime wartości i zwraca liczbę całkowitą, która wskazuje, czy to wystąpienie jest wcześniejsza niż takie same jak lub nowszy niż określona DateTime wartość.

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

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

System_CAPS_pubmethodEquals(DateTime)

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

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

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

System_CAPS_pubmethodEquals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.(Przesłania ValueType.Equals(Object)).

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

Deserializuje wartość binarną 64-bitowych i odtwarza oryginału serializowane DateTime obiektu.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

Konwertuje określony czas pliku systemu Windows równoważne czasu lokalnego.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

Konwertuje określony czas pliku systemu Windows na odpowiedni czas UTC.

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

Zwraca DateTime odpowiednikiem określonego OLE automatyzacji daty.

System_CAPS_pubmethodGetDateTimeFormats()

Konwertuje wartość tego wystąpienia reprezentacji ciągu obsługiwane przez standardowy format daty i godziny specyfikatorów formatu.

System_CAPS_pubmethodGetDateTimeFormats(Char)

Konwertuje wartość tego wystąpienia reprezentacji ciągu obsługiwane przez określoną datą standardowego i specyfikator formatu godziny.

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

Konwertuje wartość tego wystąpienia reprezentacji ciągu obsługiwane przez określoną datą standardowego i specyfikator formatu godziny i informacje o formatowaniu specyficzne dla kultury.

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

Konwertuje wartość tego wystąpienia reprezentacji ciągu obsługiwane przez standardowa Data i godzina specyfikatorów formatu i określone informacje o formatowaniu specyficzne dla kultury.

System_CAPS_pubmethodGetHashCode()

Zwraca kod skrótu dla tego wystąpienia.(Przesłania ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Pobiera Type bieżącego wystąpienia.(Dziedziczone z Object).

System_CAPS_pubmethodGetTypeCode()

Zwraca TypeCode dla typu wartości DateTime.

System_CAPS_pubmethodIsDaylightSavingTime()

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

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

Zwraca wartość wskazuje, czy określony rok jest rokiem przestępnym.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Konwertuje ciąg reprezentujący datę i godzinę na jego DateTime równoważne.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Konwertuje ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu informacji specyficznych dla kultury.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

Konwertuje ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu informacji specyficznych dla kultury i formatowanie stylu.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider)

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu podanego formatu i informacji specyficznych dla kultury. Format ciągu reprezentującego musi dokładnie pasować określonego formatu.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider, DateTimeStyles)

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu podanego formatu, informacji specyficznych dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować określonego formatu lub jest zgłaszany wyjątek.

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

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu określonej tablicy formatów, informacji specyficznych dla kultury i stylu. Format ciągu reprezentującego musi dokładnie co najmniej jednego ze wskazanych formatów lub jest zgłaszany wyjątek.

System_CAPS_pubmethodSystem_CAPS_staticSpecifyKind(DateTime, DateTimeKind)

Tworzy nowy DateTime obiekt, który ma taką samą liczbę znaczników, jak określono DateTime, ale jest wyznaczony jako czas lokalny, uniwersalny czas koordynowany (UTC) lub nie, wskazane przez określony DateTimeKind wartość.

System_CAPS_pubmethodSubtract(DateTime)

Odejmuje określoną datą i godziną z tego wystąpienia.

System_CAPS_pubmethodSubtract(TimeSpan)

Odejmuje podany czas trwania z tego wystąpienia.

System_CAPS_pubmethodToBinary()

Serializuje bieżącego DateTime obiektu wartość binarną 64-bitowy, który następnie może służyć do odtworzenia DateTime obiektu.

System_CAPS_pubmethodToFileTime()

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

System_CAPS_pubmethodToFileTimeUtc()

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

System_CAPS_pubmethodToLocalTime()

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

System_CAPS_pubmethodToLongDateString()

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

System_CAPS_pubmethodToLongTimeString()

Konwertuje wartość bieżącego DateTime obiektu na jego reprezentację ciągu równoważne dużo czasu.

System_CAPS_pubmethodToOADate()

Konwertuje wartość tego wystąpienia odpowiada dacie automatyzacji OLE.

System_CAPS_pubmethodToShortDateString()

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

System_CAPS_pubmethodToShortTimeString()

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

System_CAPS_pubmethodToString()

Konwertuje wartość bieżącego DateTime obiektu na jego reprezentację ciągu równoważnego przy użyciu konwencji formatowania bieżącej kultury.(Przesłania ValueType.ToString()).

System_CAPS_pubmethodToString(IFormatProvider)

Konwertuje wartość bieżącego DateTime obiektu na jego reprezentację ciągu równoważnego, korzystając z informacji zawartych w określonym formacie specyficzne dla kultury.

System_CAPS_pubmethodToString(String)

Konwertuje wartość bieżącego DateTime obiektu na jego reprezentację ciągu równoważnego przy użyciu podanego formatu i Konwencji formatowania bieżącej kultury.

System_CAPS_pubmethodToString(String, IFormatProvider)

Konwertuje wartość bieżącego DateTime obiektu na jego reprezentację ciągu równoważnego przy użyciu podanego formatu i informacji specyficznych dla kultury.

System_CAPS_pubmethodToUniversalTime()

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

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, DateTime)

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważny i zwraca wartość wskazującą, czy konwersja powiodła się.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu informacji o określonym formacie specyficzne dla kultury i formatowanie stylu i zwraca wartość wskazującą, czy konwersja powiodła się.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu podanego formatu, informacji specyficznych dla kultury i stylu. Format ciągu reprezentującego musi dokładnie pasować określonego formatu. Metoda zwraca wartość wskazującą, czy konwersja powiodła się.

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

Konwertuje określony ciąg reprezentujący datę i godzinę na jego DateTime równoważne przy użyciu określonej tablicy formatów, informacji specyficznych dla kultury i stylu. Format ciągu reprezentującego musi dokładnie co najmniej jednego ze wskazanych formatów. Metoda zwraca wartość wskazującą, czy konwersja powiodła się.

NazwaOpis
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Reprezentuje największa możliwa wartość z DateTime. To pole jest tylko do odczytu.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Reprezentuje wartość najmniejszy możliwy DateTime. To pole jest tylko do odczytu.

NazwaOpis
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

Dodaje określony interwał do określonej daty i godziny, reaguje nowe daty i godziny.

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

Określa, czy dwóch określonych wystąpień DateTime są równe.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

Określa, czy jeden określony DateTime jest późniejsza niż inna określona DateTime.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

Określa, czy jeden określony DateTime przedstawia datę i godzinę, która jest taka sama wcześniejsza niż innego określone DateTime.

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

Określa, czy dwóch określonych wystąpień DateTime nie są równe.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

Określa, czy jeden określony DateTime jest wcześniejsza niż inna określona DateTime.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

Określa, czy jeden określony DateTime reprezentuje datę i godzinę, która jest taka sama jak lub wcześniejsze niż inna określona DateTime.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

Odejmuje określonej daty i czasu od innego określonej daty i godziny i zwraca przedział czasu.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

Odejmuje w określonym interwale czasu z określoną datą i godziną i zwraca nową datę i godzinę.

NazwaOpis
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Zwraca bieżącą DateTime obiektu.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Konwertuje bieżącą DateTime obiektu do obiektu określonego typu.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Ten interfejs API obsługuje infrastrukturę produkt i nie jest przeznaczony do użycia bezpośrednio w kodzie. Ta konwersja nie jest obsługiwana. Podjęto próbę użycia tej metody powoduje InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

Wypełnienie SerializationInfo obiektu z danych potrzebnych do serializacji bieżącego DateTime obiektu.

System_CAPS_noteUwaga

Aby wyświetlić kod źródłowy .NET Framework dla tego typu, zobacz Reference Source. Można przejrzeć kod źródłowy w tryb online, Pobierz odwołanie do wyświetlenia w trybie offline i kroków opisanych źródeł (w tym poprawek i aktualizacji) podczas debugowania. see instructions.

DateTime Typ wartości reprezentuje daty i godziny z wartości z zakresu od 00:00:00 (północ), 1 stycznia 0001 Anno Domini (typowe Era) za pośrednictwem 11:59:59 PM, 31 grudnia 9999 r. (R) w kalendarza gregoriańskiego.

Wartości czasu są mierzone w jednostkach 100-nanosekundowych o nazwie znaczniki i określonej daty to liczbę taktów od momentu 12:00, a 1 stycznia, 0001 r. N.E. (R) w GregorianCalendar kalendarza (z wyjątkiem Takty dodanych przestępnego sekund). Na przykład wartość impulsów 31241376000000000L reprezentuje datę piątek, 01 stycznia 0100 północ 12:00:00. A DateTime wartość jest zawsze wyrażona w kontekście jawnego lub domyślna kalendarz.

System_CAPS_noteUwaga

Jeśli pracujesz z wartość impulsów, że ma zostać przekonwertowany na niektóre inne interwał czasu, takich jak minut i sekund, należy użyć TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, lub TimeSpan.TicksPerMillisecond stała, aby dokonać konwersji. Na przykład, aby dodać liczbę sekund reprezentowany przez określoną liczbę znaczniki osi Second składnika DateTime wartości, można użyć wyrażenia dateValue.Second + nTicks/Timespan.TicksPerSecond.

W tej sekcji:

Utworzenie wystąpienia obiektu typu DateTime
Wartości daty/godziny i ich reprezentacji ciągu
Konwersja ciągów na wartości typu DateTime
Uwagi dotyczące wersji
Wartości typu DateTime
Operacje typu DateTime
Rozpoznawanie daty i godziny
Vs daty/godziny. TimeSpan
Wartości typu DateTime i kalendarzy
Utrwalanie wartości daty/godziny
Uwagi dotyczące współdziałania COM

Można utworzyć nowy DateTime wartość w jednej z następujących sposobów:

  • Wywołując jedną z przeciążeń DateTime Konstruktor, który pozwala na określenie określonych elementów wartość daty i godziny (np. rok, miesiąc i dzień lub liczbę taktów). Następująca instrukcja przedstawiono wywołania do jednego z DateTime konstruktorów tworzenie daty z danego roku, miesiąc, dzień, godzinę, minutę i sekundę.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • Za pomocą dowolnego składnię charakterystyczną dla kompilatora deklarowania wartości daty i godziny. Na przykład następująca instrukcja języka Visual Basic inicjuje nowy DateTime wartość.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • Przypisując DateTime obiektów zwrócona przez właściwość lub metoda wartość daty i godziny. W poniższym przykładzie przypisano bieżącej daty i czasu, bieżącą datę w formacie uniwersalnego czasu koordynowanego (UTC) i czas i bieżącą datę do trzech nowych DateTime zmiennych.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • Analizując reprezentację ciągu wartość daty i godziny. Parse, ParseExact, TryParse, I TryParseExact wszystkie metody konwertowanie ciągu na jej odpowiednik wartość daty i godziny. W poniższym przykładzie użyto Parse metodę, aby przeanalizować ciągu i przekształcić ją w DateTime wartość.

    string dateString = "5/1/2008 8:30:52 AM";
    DateTime date1 = DateTime.Parse(dateString, 
                              System.Globalization.CultureInfo.InvariantCulture); 
    

    Należy pamiętać, że TryParse i TryParseExact metody wskazuje, czy określony ciąg zawiera nieprawidłowy reprezentację DateTime wartość oprócz przeprowadzania konwersji.

  • Wywołując DateTime struktury niejawne domyślnego konstruktora. (Aby uzyskać szczegółowe informacje na niejawne domyślny konstruktor obiektu typu wartości, zobacz Typy wartości (odwołanie w C#).) Deklarowanie jest równoważne przybliżonej dla kompilatorów wspierających, DateTime wartość bez jawnie przypisanie do niego daty i godziny. Poniższy przykład przedstawia wywołanie DateTime niejawne domyślnego konstruktora w języku C# i Visual Basic, a także DateTime deklaracja zmiennej z żadnego przypisania w języku Visual Basic.

    DateTime 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));
    

Wewnętrznie, wszystkie DateTime wartości są reprezentowane jako liczbę znaczników (Liczba 100-nanosekundowych interwałów), które upłynęły od północy 12:00:00 1 stycznia 0001. Rzeczywiste DateTime wartość zależy od sposobu, w którym ta wartość jest wyświetlany, gdy wyświetlany w przypadku elementu interfejsu użytkownika lub zapisywane w pliku. Wygląd DateTime wartość jest wynik operacji formatowania. Formatowanie to proces konwertowania wartości na jej reprezentację ciągu.

Ponieważ wygląd wartości daty i godziny zależy od takich czynników, jak kultury, międzynarodowych standardów wymagań aplikacji i osobistych preferencji DateTime struktura zapewnia dużą elastyczność w formatowaniu wartości daty i godziny za pomocą przeciążenia metody jego ToString metody. Wartość domyślna DateTime.ToString() metoda zwraca reprezentację ciągu przy użyciu bieżącej kultury krótkiej daty i długi czas wzorzec wartość daty i godziny. W poniższym przykładzie użyto domyślnie DateTime.ToString() metody, aby wyświetlić datę i godzinę, przy użyciu krótkiej daty i długi czas wzorca dla en US kultury bieżącej kultury, na komputerze, na którym uruchomiono przykładzie.

DateTime 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

DateTime.ToString(IFormatProvider) Metoda zwraca reprezentację ciągu wartość daty i godziny przy użyciu krótkiej daty i długi czas wzorzec określoną kulturę. W poniższym przykładzie użyto DateTime.ToString(IFormatProvider) metody, aby wyświetlić datę i godzinę, przy użyciu krótkiej daty i długi czas wzorca dla kultury fr-FR.

DateTime 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

DateTime.ToString(String) Metoda zwraca reprezentację ciągu daty i godziny w formacie zdefiniowanym przez specyfikator formatu standardowych lub niestandardowych, za pomocą Konwencji formatowania bieżącej kultury. W poniższym przykładzie użyto DateTime.ToString(String) metodę w celu wyświetlenia pełnej daty i czasu wzorzec en US kultury bieżącej kultury, na komputerze, na którym uruchomiono przykładzie.

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

DateTime.ToString(String, IFormatProvider) Metoda zwraca reprezentację ciągu daty i godziny w formacie zdefiniowanym przez specyfikator formatu określonego, przy użyciu konwencji formatowania określonej kultury. W poniższym przykładzie użyto DateTime.ToString(String, IFormatProvider) metodę w celu wyświetlenia pełnej daty i czasu wzorca dla kultury fr-FR.

DateTime 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

Aby uzyskać więcej informacji na temat formatowania DateTime wartości, zobacz Standardowe ciągi formatujące datę i godzinę i Niestandardowe ciągi formatujące datę i godzinę.

Podczas analizowania polega na konwertowaniu reprezentację ciągu daty i godziny do DateTime wartości. Zazwyczaj ciągi daty i godziny są dwie różne metody użycia w aplikacjach:

  • Reprezentują datę i godzinę, które wymagają różnych formularzy i który uwzględnia konwencje bieżącej kultury lub określoną kulturę. Na przykład aplikacja może zezwolić użytkownikowi, w których bieżącej kultury jest en US, aby wprowadzić wartość daty "12/15/2013" lub "15 grudniu 2013", i umożliwia użytkownikowi, w których bieżącej kultury jest wprowadzanie wartości daty "12/15/2013" lub "15 grudniu 2013" en-GB.

  • Reprezentują datę i godzinę w formacie wstępnie zdefiniowane. Na przykład aplikacja może serializować daty w postaci "20130103" niezależne od kultury, na którym aplikacja jest uruchomiona, lub może wymagać wprowadzać datę w formacie daty krótkiej bieżącej kultury.

Można użyć Parse lub TryParse metodę, aby przekonwertować ciąg, który może być jednego z typowych formatów daty i godziny używany przez kultury do uwzględnienia DateTime wartość. W poniższym przykładzie pokazano, jak używasz TryParse do konwertowania ciągów daty w wielu różnych formatach specyficzne dla kultury do DateTime wartości. Zmienia bieżącej kultury angielski (Polska) i wywołania GetDateTimeFormats() metody do wygenerowania tablica ciągów daty i godziny. Następnie przekazuje każdego elementu w tablicy, tak aby TryParse metody. Dane wyjściowe w przykładzie pokazano, że metodę analizowania mógł pomyślnie skonwertować wszystkich specyficzne dla kultury ciągów daty i godziny.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

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

      Console.WriteLine("{0,-37} {1,-19}\n", "Date String", "Date");
      foreach (var dateString in date1.GetDateTimeFormats()) {
         DateTime parsedDate;
         if (DateTime.TryParse(dateString, out parsedDate))
            Console.WriteLine("{0,-37} {1,-19}", dateString, DateTime.Parse(dateString));
         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("   {0}", badFormat);         
      }
   }
}
// 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

Można użyć TryParse i TryParseExact metod do przekonwertowania ciągu daty i godziny należy odpowiadających określonym formacie lub formaty DateTime wartość. Określić wymagany format lub formatów jako parametr do analizowania methodby przy użyciu co najmniej jednego lub ciągi formatujące datę i godzinę. W poniższym przykładzie użyto TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodę, aby przekonwertować ciągów, które muszą być w formacie "RRRRMMDD" lub "HHmmss" format DateTime wartości.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      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, 
                                    DateTimeStyles.AllowWhiteSpaces |
                                    DateTimeStyles.AdjustToUniversal,
                                    out parsedDate))
            Console.WriteLine("{0} --> {1:g}", dateString, parsedDate);
         else
            Console.WriteLine("Cannot convert {0}", 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

Parse i ParseExact metody zgłosić wyjątek, jeśli można przekonwertować na ciąg DateTime nie można analizować wartości. TryParse i TryParseExact metody zwracają Boolean wartość wskazującą, czy konwersja powiodła się czy nie. Ponieważ analizy operacji ciągi daty i godziny, szczególnie jeśli ciągi są wejściowych przez użytkowników, zwykle ma współczynnik awaryjności wysoki, a ponieważ obsługi wyjątków jest kosztowna, należy używać TryParse lub TryParseExact metod w scenariuszach, w których wydajności jest ważne lub konwersje podlegają wysoki współczynnik awarii.

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

Przed .NET Framework w wersji 2.0 DateTime struktura zawiera pole 64-bitowych składa się z polem 2-bitowych nieużywane połączony z prywatnej Ticks pola, które jest polem niepodpisane 62-bitowe znajduje się kod znaczników, które reprezentują datę i godzinę. Wartość Ticks pola można uzyskać z Ticks właściwości.

Począwszy od programu .NET Framework 2.0, DateTime struktura zawiera pole 64-bitowych zawierający pole private rodzaju połączonych z polem znaczniki osi. Rodzaju pole jest polem 2-bitowego, która wskazuje, czy DateTime struktury reprezentuje czasu lokalnego, uniwersalny czas koordynowany (UTC) lub czas w strefie czasowej nieokreślony. Pole Kind jest używane podczas wykonywania konwersje czasu między strefami czasowymi, ale nie dla porównania czas lub arytmetyczne. Wartość pola rodzaju można uzyskać z Kind właściwości.

System_CAPS_noteUwaga

Zamiast DateTime struktury Praca z wartości daty i godziny w szczególności strefach czasowych jest DateTimeOffset struktury. DateTimeOffset Struktury przechowuje informacje o datę i godzinę w prywatnej DateTime pola i liczbę minut, przez które które daty i godziny różni się od czasu UTC w prywatnym Int16 pola. Dzięki temu dla DateTimeOffset wartość do uwzględnienia czasu, w szczególności strefie czasowej, natomiast DateTime wartość jednoznacznie można uwzględnić tylko UTC oraz czas lokalnej strefy czasowej. Aby uzyskać informacje o tym, kiedy należy używać DateTime struktury lub DateTimeOffset struktury podczas pracy z wartości daty i godziny, zobacz Wybieranie pomiędzy elementem DateTime, DateTimeOffset, TimeSpan i TimeZoneInfo.

Opisy wartości czasu w DateTime typu są często wyrażane standardowego uniwersalny czas koordynowany (UTC), czyli nazwa uznanych czas uniwersalny Greenwich (GMT). Uniwersalny czas koordynowany to czas mierzony na zerowej długości stopni, punktem początkowym UTC. Czas letni nie jest stosowana na czas UTC.

Czas lokalny jest określana względem daną strefę czasową. Strefa czasowa jest skojarzony z przesunięcia strefy czasowej, która jest przesunięcie strefy czasowej, mierzony w godzinach od punktu pochodzenia UTC. Ponadto czasu lokalnego, opcjonalnie dotyczy czasu letniego, które zwiększa lub zmniejsza godziny od długości dziennie. W rezultacie czas lokalny jest obliczany przez dodanie przesunięcia strefy czasowej UTC i dopasowywanie czasu w razie potrzeby. Przesunięcie strefy czasowej w miejscu pochodzenia UTC wynosi zero.

Czas UTC jest odpowiednia do obliczeń, porównania i przechowywania daty i godziny w plikach. Czas lokalny jest odpowiednia do wyświetlania na interfejsy użytkownika aplikacji klasycznych. Strefa czasowa aplikacjami (np. wiele aplikacji sieci Web) muszą pracować z wieloma innymi stref czasowych.

Jeśli Kind właściwość DateTime obiekt jest DateTimeKind.Unspecified, jest nieokreślony, w czy czas reprezentowany jest czasu lokalnego, czasu UTC lub czasu w innych strefy czasowej.

Obliczanie przy użyciu DateTime struktury, takich jak Add lub Subtract, nie modyfikuje wartość struktury. Zamiast tego obliczenia zwraca nową DateTime struktury, którego wartość jest wynikiem obliczenia.

Operacje konwersji między strefami czasowymi (np. między czasem UTC a lokalnym lub między strefami czasowymi) uwzględnienia czasu letniego, ale operacje arytmetyczne i porównania nie.

DateTime Struktury sam oferuje ograniczoną obsługę do konwertowania z jedną strefę czasową. Można użyć ToLocalTime metoda konwersji UTC na czas lokalny lub użytkownik może używać ToUniversalTime metodę, aby przekonwertować od lokalnego czasu na czas UTC. Jednak pełny zestaw metod konwersji strefy czasowej jest dostępna w TimeZoneInfo klasy. Za pomocą następujących metod, można przekonwertować czasu w jednym stref czasowych na świecie do czasu w innych strefie czasowej.

Obliczenia i porównania DateTime obiektów mają znaczenie tylko wtedy, gdy obiekty reprezentują razy w tej samej strefie czasowej. Można użyć TimeZoneInfo obiektu do reprezentowania DateTime wartości czasu strefy, mimo że dwa są luźno powiązane. (Czyli, DateTime obiekt nie ma właściwości, która zwraca obiekt, który reprezentuje tego wartość daty i godziny w strefie czasowej innej niż Kind właściwości.) Z tego powodu w aplikacji obsługujących strefę czasową, konieczne jest zastosowanie mechanizmu zewnętrznych, aby określić strefę czasową, w którym DateTime obiekt został utworzony. Na przykład można użyć struktury, która opakowuje zarówno DateTime wartość i TimeZoneInfo obiekt, który reprezentuje DateTime wartości strefy czasowej. Aby uzyskać szczegółowe informacje o użyciu czasu UTC w obliczeniach i porównania z DateTime wartości, zobacz Wykonywanie operacji arytmetycznych na wartościach dat i godzin.

Każdy DateTime elementu członkowskiego niejawnie korzysta z kalendarza gregoriańskiego jego operacji, z wyjątkiem konstruktorów określić kalendarz, ani metody z parametrem pochodzi z IFormatProvider, takich jak System.Globalization.DateTimeFormatInfo, niejawnie Określa kalendarz.

Działania członków DateTime typu uwzględnia szczegóły konta, takich jak przestępnego i liczbę dni w miesiącu.

Dwa inne typowe operacje z DateTime wartości obejmują konwertowania wartości daty i godziny do lub z reprezentacji ciągu. Proces konwersji DateTime wartość do reprezentacji ciągu jest operacją formatowania; Aby uzyskać więcej informacji na temat formatowania, zobacz DateTime wartości i ich reprezentacji ciągu. Proces konwersji reprezentację ciągu daty i godziny do DateTime wartość jest operacją analizy; Aby uzyskać więcej informacji na temat analizy, zobacz Konwertowanie ciągów na wartości typu DateTime.

System_CAPS_noteUwaga

Jako alternatywę do wykonania na arytmetyczne daty i czasu DateTime wartości do mierzenia czas, który upłynął, można użyć Stopwatch klasy.

Ticks Właściwości wyraża wartości daty i godziny w jednostkach co 10 milionowych sekundy i Millisecond właściwość zwraca tysięczne drugiej wartości daty i godziny. Jednak jeśli używane są powtarzane wywołania DateTime.Now właściwości do mierzenia czas, który upłynął i dotyczy przedziały czasu małych mniej niż 100 MS, należy zauważyć, że wartości zwracane przez DateTime.Now właściwości są zależne od zegar systemowy, który w systemach Windows 7 i Windows 8 o rozdzielczości około 15 milisekund.

Poniższy przykład przedstawia zależność wartości bieżącej daty i godziny na podstawie rozdzielczości zegara systemowego. W tym przykładzie zewnętrzne pętli powtarza 20 razy, i wewnętrzny pętli służy do opóźnienia zewnętrzne pętli. Jeśli wartość licznika pętli zewnętrzne wynosi 10, wywołanie Thread.Sleep metody opóźnienia pięć milisekund. Jak dane wyjściowe w przykładzie pokazano, liczbę milisekund zwrócony przez DateTime.Now.Milliseconds zmienić tylko po wywołaniu właściwości Thread.Sleep.

using System;
using System.Threading;

public class Example
{
   public static void Main()
   {
      String output = "";
      for (int ctr = 0; ctr <= 20; ctr++) {
         output += String.Format("{0}\n", DateTime.Now.Millisecond);
         // Introduce a delay loop.
         for (int delay = 0; delay <= 1000; delay++)
         {}

         if (ctr == 10) {
            output += "Thread.Sleep called...\n";
            Thread.Sleep(5);
         }
      }
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       Thread.Sleep called...
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143

DateTime i TimeSpan typów wartości różnią się w tym DateTime reprezentuje moment w czasie, podczas gdy TimeSpan reprezentuje przedział czasu. Oznacza to, na przykład, że można odejmować jedno wystąpienie DateTime z innego uzyskanie TimeSpan obiekt, który reprezentuje czas między nimi. Lub można dodać dodatnią TimeSpan do bieżącego DateTime uzyskanie DateTime wartość, która reprezentuje datą przyszłą.

Można dodawać lub odjęcia przedział czasu z DateTime obiektu. Przedziały czasu może być ujemna lub dodatnia, może zostać wyrażona w jednostkach, takich jak taktami lub sekund lub może zostać wyrażona jako TimeSpan obiektu.

Biblioteka klas programu .NET Framework zawiera szereg klas kalendarz, z których pochodzą od Calendar klasy. Są to:

Każdej kultury używa domyślnego kalendarza wynika z jego tylko do odczytu CultureInfo.Calendar właściwości i obsługuje co najmniej jeden kalendarzy wynika z jego tylko do odczytu CultureInfo.OptionalCalendars właściwości. Kalendarza aktualnie używane przez konkretnego CultureInfo obiektu jest zdefiniowana przez jego DateTimeFormatInfo.Calendar właściwości; musi być jedną z kalendarzy w CultureInfo.OptionalCalendars tablicy.

Kultura bieżącego kalendarza jest używany podczas wszystkich operacji formatowania dla tej kultury. Na przykład kalendarz domyślnej kultury perski (Iran) jest um al Qura kalendarza, która jest reprezentowana przez UmAlQuraCalendar klasy. Gdy CultureInfo obiekt, który reprezentuje kultury perski (Iran) jest używany w formatowania daty i godziny operacji, um al Qura kalendarza jest używany domyślnie i kalendarza gregoriańskiego jest używana tylko wtedy, gdy kultury DateTimeFormatInfo.Calendar zmienić właściwości, jak przedstawiono na poniższym przykładzie.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = new DateTime(2016, 5, 28);

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

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
// 08/03/1395 12:00:00 ?.?
// 28/05/2016 12:00:00 ?.?

Kultura bieżącego kalendarza służy także we wszystkich operacjach przetwarzania dla tej kultury, jak przedstawiono na poniższym przykładzie.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = DateTime.Parse("08/03/1395", faIR);
      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
//       08/03/1395 12:00:00 ?.?
//       28/05/2016 12:00:00 ?.?

Można również utworzyć wystąpienie DateTime wartość na podstawie daty i godziny elementy (takie jak liczba rok, miesiąc i dzień) kalendarza określonego przez wywołanie metody konstruktora elementu DateTime zawierającą calendar parametr i przekazanie jej Calendar obiekt, który reprezentuje tego kalendarza. Poniższy przykład dokonuje tego przy użyciu elementów datę i godzinę, z UmAlQuraCalendar kalendarza.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var dat = new DateTime(1395, 8, 18, faIR.DateTimeFormat.Calendar);
      Console.WriteLine("Umm-al-Qura date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Gregorian date:   {0:d}", dat);
   }
}
// The example displays the following output:
//       Umm-al-Qura date: 18/08/1395
//       Gregorian date:   11/8/2016

DateTimeKonstruktory, które nie zawierają calendar parametru założono, że elementy daty i godziny są wyrażone jako jednostki w kalendarza gregoriańskiego.

Wszystkie inne DateTime właściwości i metody Użyj kalendarza gregoriańskiego. Na przykład DateTime.Year właściwość zwraca rok kalendarza gregoriańskiego i DateTime.IsLeapYear(Int32) metody, przy założeniu, że year parametr jest rok kalendarza gregoriańskiego. Każdy DateTime elementu członkowskiego, który korzysta z kalendarza gregoriańskiego ma odpowiednie członkiem Calendar klasy, która korzysta z określonego kalendarza. Na przykład Calendar.GetYear metoda zwraca roku w kalendarzu określonych i Calendar.IsLeapYear interpretuje metody year parametru jako liczba roku w kalendarzu określonych. Poniższy przykład korzystać z obu DateTime i odpowiednich członków UmAlQuraCalendar klasy.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var cal = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, cal);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Year: {0}", cal.GetYear(dat));
      Console.WriteLine("Leap year: {0}\n", 
                        cal.IsLeapYear(cal.GetYear(dat)));

      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Year: {0}", dat.Year);
      Console.WriteLine("Leap year: {0}", DateTime.IsLeapYear(dat.Year));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Year: 1395
//       Leap year: True
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Year: 2016
//       Leap year: True

Mimo że DateTime struktura zawiera DayOfWeek właściwość, która zwraca dzień tygodnia kalendarza gregoriańskiego, nie zawiera elementu członkowskiego, który pozwala na pobieranie numer tygodnia w roku. Można pobrać tydzień roku, wywołaj kalendarza poszczególnych Calendar.GetWeekOfYear metody. Poniższy przykład stanowi ilustrację.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var umAlQura = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, umAlQura);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Day of Week: {0}", umAlQura.GetDayOfWeek(dat));
      Console.WriteLine("Week of year: {0}\n", 
                        umAlQura.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                               DayOfWeek.Sunday));

      var greg = new GregorianCalendar(); 
      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Day of Week: {0}", dat.DayOfWeek);
      Console.WriteLine("Week of year: {0}", 
                         greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                            DayOfWeek.Sunday));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Day of Week: Tuesday
//       Week of year: 34
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Day of Week: Tuesday
//       Week of year: 46

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

Można ją utrwalić DateTime wartości na cztery sposoby:

Niezależnie od tego, możesz wybrać techniki, upewnij się, że procedura, która przywraca DateTime wartości nie spowodować utratę danych lub zgłosić wyjątek. DateTimew przypadku obustronne wartości. Oznacza to, że oryginalna wartość i przywrócone wartości powinny być takie same. I w przypadku oryginalnej DateTime wartość reprezentuje pojedynczy błyskawicznych czasu, należy zidentyfikować tym momencie czas po przywróceniu.

Aby pomyślnie przywrócić DateTime wartości, które są trwałe jako ciągi, wykonać następujące czynności:

  • Mieć tej samej wartości domyślne specyficzne dla kultury formatowanie po przywróceniu ciągu jako utrwalone po. Aby upewnić się, że ciąg mogą być przywracane na komputerze, którego bieżącej kultury różni się od kultury systemu został zapisany na, należy wywołać ToStringprzeciążenia, aby zapisać ciąg przy użyciu konwencji Niezmienna kultura i wywołanie Parse(String, IFormatProvider, DateTimeStyles) lub TryParse(String, IFormatProvider, DateTimeStyles, DateTime) przeciążenia, aby przywrócić ciąg przy użyciu konwencji Niezmienna kultura. Nigdy nie używaj ToString(), Parse(String), lub TryParse(String, DateTime) przeciążenia, które używają konwencje bieżącej kultury wątku.

  • Dane reprezentuje pojedynczy chwilę czasu, upewnij się, że reprezentuje tego samego moment w czasie, gdy zostanie przywrócona, nawet wtedy, gdy jest przywracany w systemie, który używa innej strefie czasowej. Aby to zrobić, należy konwertować DateTime wartość uniwersalny czas koordynowany (UTC) przed zapisaniem. Można również serializacji wartości oraz informacje o strefie czasowej; Aby uzyskać więcej informacji na temat tej metody, zobacz dane serializacji daty/godziny i strefy czasowej.

Najbardziej typowe błąd po trwałym DateTime wartości jako ciągi jest zależne od Konwencji formatowania domyślne lub bieżącej kultury. Jeśli bieżącej kultury jest inny, gdy zapisywanie i przywracanie ciągi wystąpienia problemów. Poniższy przykład przedstawia tych problemów. Zapisuje pięć daty przy użyciu konwencji formatowania bieżącej kultury, w tym przypadku jest angielski (Stany Zjednoczone). Przywraca go daty przy użyciu konwencji formatowania bieżącej kultury, w tym przypadku jest angielski (Polska). Ponieważ Konwencji formatowania dwóch kultur są różne, dwa dat nie można przywrócić, a pozostałe trzy daty będą interpretowane niepoprawnie. Ponadto jeśli oryginalne wartości daty i godziny reprezentują pojedynczego momentów w czasie przywróconej czasy są nieprawidłowe, ponieważ informacje o strefie czasowej zostaną utracone.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\BadDates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      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: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      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("'{0}' --> {1:f}", inputValue, dateValue);
         }
         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:
//       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...

Przesyłania danych DateTime wartości pomyślnie, wykonaj następujące kroki:

  1. Jeśli wartości reprezentują pojedynczego chwil czasu, przekonwertować je od lokalnego czasu na czas UTC przez wywołanie metody ToUniversalTime metody.

  2. Przekonwertować daty na ich oświadczenia ciąg przez wywołanie metody ToString(String, IFormatProvider) lub String.Format(IFormatProvider, String, Object[]) przeciążenia. Użyj konwencji formatowania z kulturą niezmienną określając CultureInfo.InvariantCulture jako provider argumentu. Określ, czy wartość należy obustronne za pomocą "O" lub "R".

  3. Podczas wywoływania Parse(String, IFormatProvider, DateTimeStyles) lub TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metody.

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

  1. Przeanalizował danych przez wywołanie metody ParseExact lub TryParseExact przeciążenia. Określ CultureInfo.InvariantCulture jako provider argument, a następnie użyj tego samego standardowego formatu ciągu użyte do format argumentu podczas konwersji. Obejmują DateTimeStyles.RoundtripKind wartość w styles argumentu.

  2. Jeśli DateTime wartości reprezentują pojedynczego chwil w czasie, wywołanie ToLocalTime metodę, aby przekonwertować tę datę przeanalizowane w formacie UTC na czas lokalny.

W poniższym przykładzie użyto Niezmienna kultura i ciągu standardowym formacie "O", aby upewnić się, że DateTime wartości, które są zapisywany i przywracany reprezentują tego samego moment w czasie, niezależnie od systemu, kultury i strefy czasowej z systemów źródłowych i docelowych.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\Dates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      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: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      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 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      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("'{0}' --> {1:f}", 
                              inputValue, dateValue.ToLocalTime());
         }
         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...

Zamiast utrwalanie DateTime wartość jako ciąg, można zachować go jako Int64 wartość reprezentującą liczbę znaczników. W takim przypadku nie trzeba wziąć pod uwagę kultury systemów DateTime wartości są zachowywane i przywrócone na.

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

  • Jeśli DateTime wartości reprezentują pojedynczego momentów w czasie, wykonać ich konwersję na UTC, wywołując ToUniversalTime metody.

  • Pobrać liczbę Takty reprezentowany przez DateTime wartość z jego Ticks właściwości.

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

  1. Utwórz wystąpienie nowego DateTime obiektu przez przekazywanie Int64 do wartości DateTime(Int64) konstruktora.

  2. Jeśli DateTime wartość reprezentuje pojedynczy moment w czasie, należy konwertować go od czasu UTC na czas lokalny, wywołując ToLocalTime metody.

Poniższy przykład będzie się powtarzał tablicę DateTime wartości jako liczby całkowite w systemie w Stanach Zjednoczonych Czas pacyficzny strefy. Go przywraca w systemie w strefie UTC. Zawiera plik, który zawiera liczby całkowite Int32 wartość, która wskazuje całkowitą liczbę Int64 wartości, które od razu po nim.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

class Example
{
   private const string filename = @".\IntDates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      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: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      long[] 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; 
      }
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryWriter 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 RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      FileStream fs = new FileStream(filename, 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 {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      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...

Zamiast zapisywania DateTime wartości jako ciągi lub liczb całkowitych, które następnie trzeba przekonwertować z powrotem do DateTime wartości, można ją utrwalić DateTime wartości za pomocą serializacji do strumienia lub plik, a następnie przywróć je do deserializacji. W takim przypadku DateTimedanych jest serializowany w formacie niektóre określony obiekt i obiekty zostaną przywrócone, gdy są one deserializacji. Element formatujący lub serializator, takich jak XmlSerializer lub BinaryFormatter, obsługuje proces serializacji i deserializacji. Aby uzyskać więcej informacji na temat serializacji i typy serializacji obsługiwane przez program .NET Framework, zobacz Serializacji w programie .NET Framework.

W poniższym przykładzie użyto XmlSerializer klasy do serializacji i deserializacji DateTime wartości reprezentujących wszystkie leap dni roku w wieku dwudziestego pierwszego. Dane wyjściowe reprezentuje wynik, jeśli przykładzie jest uruchamiana w systemie, w których bieżącej kultury jest angielski (Polska). Ponieważ firma Microsoft już rozszeregować DateTime sam kod obiekt nie ma obsługi kultury różnice formatów daty i godziny.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Xml.Serialization;

class Example
{
   private const string filename = @".\LeapYears.xml";

   public static void Main()
   {
      // Serialize the data.
      List<DateTime> 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();

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

      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 (FileStream fs = new FileStream(filename, FileMode.Open)) {
         deserializedDates = (DateTime[]) serializer.Deserialize(fs);
      } 

      // Display the dates.
      Console.WriteLine("Leap year days from 2000-2100 on an {0} system:",
                        Thread.CurrentThread.CurrentCulture.Name);
      int nItems = 0;
      foreach (var dat in deserializedDates) {
         Console.Write("   {0:d}     ", dat);
         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

Poprzedni przykład nie zawiera informacje o czasie. Jednak jeśli DateTime wartość reprezentuje moment, w czasie i jest wyrażona jako czas lokalny, należy ją przekonwertować od lokalnego czasu na czas UTC przed szeregując go przez wywołanie metody ToUniversalTime metody. Po deserializacji się go, należy ją przekonwertować od czasu UTC na czas lokalny przez wywołanie metody ToLocalTime metody. W poniższym przykładzie użyto BinaryFormatter klasy do serializacjiDateTime danych w systemie w Stanach Zjednoczonych Pacyficzny standardowa strefy czasowej i zdeserializować w systemie w strefie UTC.

using System;
using System.IO;
using System.Globalization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;

class Example
{
   private const string filename = @".\Dates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      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) }; 
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryFormatter bin = new BinaryFormatter();

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      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 RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

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

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      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) 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...

Poprzednich przykładach ma wszystkie założono, że DateTime wartości są wyrażane jako czas lokalny i przekonwertować wartości między czasem UTC a lokalnym, więc odzwierciedlają samym moment, w czasie w systemach źródłowych i docelowych. DateTimewartości mogą również uwzględniać chwil w czasie w strefie czasowej niż lokalne i UTC. W takim przypadku ponieważ DateTime struktury nie są znane strefy czasowej, należy go serializować zarówno DateTimewartość i TimeZoneInfo obiekt, który reprezentuje jego strefy czasowej. Aby to zrobić, należy utworzyć typu, których pola zawiera zarówno DateTime wartość i strefy czasowej. W poniższym przykładzie zdefiniowano DateWithTimeZone struktury, która ilustruje sposób może to zrobić.

using System;

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

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

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

      public DateTime DateTime 
      { get { return (dt); }
        set { dt = value; } }
   }
}
System_CAPS_importantWażne

DateWithTimeZone Struktura jest używana w następne dwa przykłady, które serializacji i deserializacji tablicy DateWithTimeZone obiektów. Aby uruchomić przykłady, należy najpierw utworzyć biblioteki klas, który zawiera DateWithTimeZone struktury, a następnie dodaj odwołanie do niej podczas kompilowania każdy przykład.

Za pomocą DateWithTimeZone struktury, można następnie zachować daty i godziny oraz informacje o strefie czasowej. W poniższym przykładzie użyto BinaryFormatter klasy do serializacji tablicę DateWithTimeZoneobiektów.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   public static void Main()
   {
      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")) };
      FileStream fs = new FileStream(@".\Schedule.bin", FileMode.Create);
      BinaryFormatter formatter = new BinaryFormatter();
      try {
         formatter.Serialize(fs, dates);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Serialization failed. Reason: {0}", 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

Poniższy przykład wywołuje BinaryFormatter.Deserialize metody do deserializacji.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   private const string filename = @".\Schedule.bin";

   public static void Main()
   {
      FileStream fs;
      if (File.Exists(filename))
         fs = new FileStream(filename, FileMode.Open);
      else {
         Console.WriteLine("Unable to find file to deserialize.");
         return;
      }

      BinaryFormatter formatter = new BinaryFormatter();
      DateWithTimeZone[] dates;
      try {
         dates = (DateWithTimeZone[]) formatter.Deserialize(fs);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Deserialization failed. Reason: {0}", 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

A DateTime wartość, która jest przenoszona do aplikacji modelu COM, a następnie jest przenoszona z powrotem do aplikacji zarządzanej, jest nazywany przesyłania danych. Jednak DateTime nie ma wartość, która określa tylko raz obustronne zgodnie z oczekiwaniami może.

Jeśli zostanie wyrównana tylko raz, takie jak 3 godziny, końcowego Data i godzina jest 30 grudnia 1899 r. N.E. na 3:00 w dniu, zamiast, 1 stycznia 0001 r. N.E. godzinie 3:00 Dzieje się tak, ponieważ program .NET Framework i COM założenie domyślnej daty, gdy został określony tylko raz. Jednak COM system przyjmie podstawowej daty 30 grudnia 1899 r. N.E. podczas podstawowej daty, 1 stycznia 0001 r. N.E. przyjęto założenie, .NET Framework

Po upływie tylko raz z programu .NET Framework modelowi COM specjalne przetwarzanie jest realizowane konwertujący czas do formatu używanego przez COM. Po upływie tylko raz z modelu COM programu .NET Framework Brak specjalnego przetwarzania odbywa się ponieważ który spowoduje uszkodzenie uzasadnionych daty i godziny w tym miejscu lub przed 30 grudnia 1899. Oznacza to też, jeśli data rozpoczyna się jego przesyłania danych z modelu COM, .NET Framework i COM zachować daty.

Zachowanie środowiska .NET Framework i COM oznacza, że jeśli przechodzenia Twojej aplikacji DateTime określający tylko raz, aplikacji należy pamiętać zmodyfikować lub Ignoruj błędne datę z końcowym DateTime obiektu.

W poniższym przykładzie pokazano sposób porównywania około równoważne DateTime wartości, akceptując w niewielkim stopniu różnica przy deklarowaniu je w taki sam.

using System;

class DateTimeTester 
{
   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 Main() 
	{
      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 ({0}) ~= d1 ({1}): {2}",
                        d1, d1, RoughlyEquals(d1, d1, window, freq));
      Console.WriteLine("d1 ({0}) ~= d2 ({1}): {2}", 
                        d1, d2, RoughlyEquals(d1, d2, window, freq));
      Console.WriteLine("d1 ({0}) ~= d3 ({1}): {2}", 
                        d1, d3, RoughlyEquals(d1, d3, window, freq));
      Console.WriteLine("d1 ({0}) ~= d4 ({1}): {2}", 
                        d1, d4, RoughlyEquals(d1, d4, window, freq));
      Console.WriteLine("d1 ({0}) ~= d5 ({1}): {2}", 
                        d1, d5, RoughlyEquals(d1, d5, window, freq));

      Console.WriteLine("d1 ({0}) ~= d6 ({1}): {2}", 
                        d1, d6, RoughlyEquals(d1, d6, window, freq));
      Console.WriteLine("d1 ({0}) ~= d7 ({1}): {2}", 
                        d1, d7, RoughlyEquals(d1, d7, window, freq));
      Console.WriteLine("d1 ({0}) ~= d8 ({1}): {2}", 
                        d1, d8, RoughlyEquals(d1, d8, window, freq));
      Console.WriteLine("d1 ({0}) ~= d9 ({1}): {2}", 
                        d1, 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

Platforma uniwersalna systemu Windows
Dostępne od 8
.NET Framework
Dostępne od 1.1
Biblioteka klas przenośnych
Obsługiwane w: przenośne platformy .NET
Silverlight
Dostępne od 2.0
Windows Phone Silverlight
Dostępne od 7.0
Windows Phone
Dostępne od 8.1

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.

System_CAPS_cautionPrzestroga

Przypisywanie tego typu wystąpienia nie jest bezpieczne wątkowo na wszystkich platformach sprzętowych, ponieważ reprezentacja binarna tego wystąpienia może być zbyt duża, aby można ją było przypisać w jednej niepodzielnej operacji.

Powrót do początku
Pokaż: