本文為機器翻譯文章。如需檢視英文版,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文

DateTime 結構

 

表示時間的瞬間,通常以一天的日期和時間表示。

若要瀏覽此類型的.NET Framework 原始程式碼,請參閱Reference Source

命名空間:   System
組件:  mscorlib (於 mscorlib.dll)

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

名稱描述
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

DateTime 結構的新執行個體初始化為指定的年、月和日。

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

DateTime 結構的新執行個體初始化為指定行事曆的指定年、月和日。

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

DateTime 結構的新執行個體初始化為指定的年、月、日、時、分和秒。

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

DateTime 結構的新執行個體初始化為指定行事曆的指定年、月、日、時、分和秒。

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

DateTime 結構的新執行個體初始化為指定年、月、日、時、分、秒以及國際標準時間 (UTC) 或本地時間。

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

DateTime 結構的新執行個體初始化為指定的年、月、日、時、分、秒和毫秒。

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

DateTime 結構的新執行個體初始化為指定行事曆的指定年、月、日、時、分、秒和毫秒。

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

DateTime 結構的新執行個體初始化為指定行事曆的指定年、月、日、時、分、秒、毫秒以及國際標準時間 (UTC) 或本地時間。

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

DateTime 結構的新執行個體初始化為指定年、月、日、時、分、秒、毫秒以及國際標準時間 (UTC) 或本地時間。

System_CAPS_pubmethodDateTime(Int64)

DateTime 結構的新執行個體初始化為刻度的指定數目。

System_CAPS_pubmethodDateTime(Int64, DateTimeKind)

DateTime 結構的新執行個體初始化為指定的刻度數以及國際標準時間 (UTC) 或本地時間。

名稱描述
System_CAPS_pubpropertyDate

取得這個執行個體的日期部分。

System_CAPS_pubpropertyDay

取得由這個執行個體表示的月份天數。

System_CAPS_pubpropertyDayOfWeek

取得由這個執行個體表示的一週天數。

System_CAPS_pubpropertyDayOfYear

取得由這個執行個體表示的一年天數。

System_CAPS_pubpropertyHour

取得這個執行個體所表示日期的小時元件。

System_CAPS_pubpropertyKind

取得值,指出這個執行個體表示的時間是根據本地時間、國際標準時間 (UTC),或兩者皆非。

System_CAPS_pubpropertyMillisecond

取得這個執行個體所表示日期的毫秒元件。

System_CAPS_pubpropertyMinute

取得這個執行個體所表示日期的分鐘元件。

System_CAPS_pubpropertyMonth

取得這個執行個體所表示日期的月份元件。

System_CAPS_pubpropertySystem_CAPS_staticNow

取得 DateTime 物件,此物件會設定為這部電腦上目前的日期和時間,以本地時間表示。

System_CAPS_pubpropertySecond

取得這個執行個體所表示日期的秒數元件。

System_CAPS_pubpropertyTicks

取得表示這個執行個體日期和時間的刻度數目。

System_CAPS_pubpropertyTimeOfDay

取得這個執行個體的一天時間。

System_CAPS_pubpropertySystem_CAPS_staticToday

取得目前的日期。

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

取得 DateTime 物件,此物件會設定為這部電腦上目前的日期和時間,以國際標準時間 (UTC) 表示。

System_CAPS_pubpropertyYear

取得這個執行個體所表示日期的年份元件。

名稱描述
System_CAPS_pubmethodAdd(TimeSpan)

傳回新的 DateTime,將這個執行個體的值加上指定之 TimeSpan 的值。

System_CAPS_pubmethodAddDays(Double)

傳回新的 DateTime,將這個執行個體的值加上指定的天數。

System_CAPS_pubmethodAddHours(Double)

傳回新的 DateTime,將這個執行個體的值加上指定的時數。

System_CAPS_pubmethodAddMilliseconds(Double)

傳回新的 DateTime,將這個執行個體的值加上指定的毫秒數。

System_CAPS_pubmethodAddMinutes(Double)

傳回新的 DateTime,將這個執行個體的值加上指定的分鐘數。

System_CAPS_pubmethodAddMonths(Int32)

傳回新的 DateTime,將這個執行個體的值加上指定的月數。

System_CAPS_pubmethodAddSeconds(Double)

傳回新的 DateTime,將這個執行個體的值加上指定的秒數。

System_CAPS_pubmethodAddTicks(Int64)

傳回新的 DateTime,將這個執行個體的值加上指定的刻度數。

System_CAPS_pubmethodAddYears(Int32)

傳回新的 DateTime,將這個執行個體的值加上指定的年數。

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

比較 DateTime 的兩個執行個體,並傳回整數,這個整數表示第一個執行個體早於、同於或晚於第二個執行個體。

System_CAPS_pubmethodCompareTo(DateTime)

比較這個執行個體的值與指定的 DateTime 值,並且傳回一個整數,指出這個執行個體是早於、同於或晚於指定的 DateTime 值。

System_CAPS_pubmethodCompareTo(Object)

比較這個執行個體的值與含有指定之 DateTime 值的指定物件,並且傳回一個整數,指出這個執行個體是早於、同於或晚於指定的 DateTime 值。

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

傳回指定之月份和年份中的天數。

System_CAPS_pubmethodEquals(DateTime)

傳回值,該值指出這個執行個體的值是否等於指定之 DateTime 執行個體的值。

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

傳回值,指出兩個 DateTime 執行個體是否有相同的日期和時間值。

System_CAPS_pubmethodEquals(Object)

傳回值,指出這個執行個體 (Instance) 是否和指定的物件相等。(覆寫 ValueType.Equals(Object)。)

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

還原序列化 64 位元的二進位值,並重新建立原始的序列化 DateTime 物件。

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

將指定的 Windows 檔案時間轉換成相等的本地時間。

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

將指定的 Windows 檔案時間轉換成相等的 UTC 時間。

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

傳回等於指定 OLE Automation 日期的 DateTime

System_CAPS_pubmethodGetDateTimeFormats()

將這個執行個體的值轉換為標準日期和時間格式規範所支援的所有字串表示。

System_CAPS_pubmethodGetDateTimeFormats(Char)

將這個執行個體的值轉換為指定的標準日期和時間格式規範所支援的所有字串表示。

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

將這個執行個體的值轉換為指定的標準日期和時間格式規範和特定文化特性格式資訊所支援的所有字串表示。

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

將這個執行個體的值轉換為標準日期和時間格式規範和指定的特定文化特性格式資訊所支援的所有字串表示。

System_CAPS_pubmethodGetHashCode()

傳回這個執行個體的雜湊碼。(覆寫 ValueType.GetHashCode()。)

System_CAPS_pubmethodGetType()

取得目前執行個體的 Type(繼承自 Object。)

System_CAPS_pubmethodGetTypeCode()

傳回實值類型 TypeCodeDateTime

System_CAPS_pubmethodIsDaylightSavingTime()

指出這個 DateTime 執行個體是否在目前時區的日光節約時間範圍內。

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

傳回指定年份是否為閏年的指示。

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

將日期和時間的字串表示,轉換為其相等的 DateTime

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

使用特定文化特性格式資訊,將日期和時間的字串表示轉換為其相等的 DateTime

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

使用特定文化特性格式資訊及格式樣式,將日期和時間的字串表示轉換為其相等的 DateTime

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider)

使用指定的格式以及特定文化特性的格式資訊,將日期和時間的指定字串表示,轉換為其相等的 DateTime 字串表示的格式必須完全符合指定的格式。

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider, DateTimeStyles)

使用指定的格式、特定文化特性格式資訊以及樣式,將日期和時間的指定字串表示,轉換為其相等的 DateTime 字串表示的格式必須完全符合指定的格式,否則會擲回例外狀況。

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

使用指定的格式陣列、特定文化特性格式資訊以及樣式,將日期和時間的指定字串表示,轉換為其相等的 DateTime 字串表示的格式必須至少完全符合其中一個指定的格式,否則會擲回例外狀況。

System_CAPS_pubmethodSystem_CAPS_staticSpecifyKind(DateTime, DateTimeKind)

建立新的 DateTime 物件,此物件的刻度數與指定的 DateTime 相同,但依指定的 DateTimeKind 值所示,指定為本地時間、國際標準時間 (Coordinated Universal Time,UTC),或兩者都不是。

System_CAPS_pubmethodSubtract(DateTime)

將這個執行個體減去指定的日期和時間。

System_CAPS_pubmethodSubtract(TimeSpan)

將這個執行個體減去指定的持續期間。

System_CAPS_pubmethodToBinary()

將目前的 DateTime 物件序列化成 64 位元的二進位值,之後可以用這個值來重新建立 DateTime 物件。

System_CAPS_pubmethodToFileTime()

將目前 DateTime 物件的值轉換成 Windows 檔案時間。

System_CAPS_pubmethodToFileTimeUtc()

將目前 DateTime 物件的值轉換成 Windows 檔案時間。

System_CAPS_pubmethodToLocalTime()

將目前 DateTime 物件的值轉換成本地時間。

System_CAPS_pubmethodToLongDateString()

將目前 DateTime 物件的值轉換為其相等的完整日期 (Long Date) 字串表示。

System_CAPS_pubmethodToLongTimeString()

將目前 DateTime 物件的值轉換為其相等的完整時間 (Long Time) 字串表示。

System_CAPS_pubmethodToOADate()

將這個執行個體的值轉換為相等的 OLE Automation 日期。

System_CAPS_pubmethodToShortDateString()

將目前 DateTime 物件的值轉換為其相等的簡短日期 (Short Date) 字串表示。

System_CAPS_pubmethodToShortTimeString()

將目前 DateTime 物件的值轉換為其相等的簡短時間 (Short Time) 字串表示。

System_CAPS_pubmethodToString()

使用目前文化特性的格式化慣例,將目前 DateTime 物件的值轉換為其相等的字串表示。(覆寫 ValueType.ToString()。)

System_CAPS_pubmethodToString(IFormatProvider)

使用指定的特定文化特性格式資訊,將目前 DateTime 物件的值轉換為其相等的字串表示。

System_CAPS_pubmethodToString(String)

使用指定的格式和目前文化特性的格式化慣例,將目前 DateTime 物件的值轉換為其相等的字串表示。

System_CAPS_pubmethodToString(String, IFormatProvider)

使用指定的格式和特定文化特性的格式資訊,將目前 DateTime 物件的值,轉換為其相等的字串表示。

System_CAPS_pubmethodToUniversalTime()

將目前 DateTime 物件的值轉換成國際標準時間 (UTC)。

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, DateTime)

將日期和時間的指定字串表示,轉換為其相等的 DateTime,並傳回一個值表示轉換是否成功。

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, IFormatProvider, DateTimeStyles, DateTime)

使用指定的特定文化特性格式資訊和格式樣式,將日期和時間的指定字串表示轉換為其相等的 DateTime,並傳回值,這個值表示轉換是否成功。

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

使用指定的格式、特定文化特性格式資訊以及樣式,將日期和時間的指定字串表示,轉換為其相等的 DateTime 字串表示的格式必須完全符合指定的格式。 此方法會傳回值,這個值表示轉換是否成功。

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

使用指定的格式陣列、特定文化特性格式資訊以及樣式,將日期和時間的指定字串表示,轉換為其相等的 DateTime 字串表示的格式必須至少完全符合其中一個指定格式。 此方法會傳回值,這個值表示轉換是否成功。

名稱描述
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

代表 DateTime 最大的可能值。 此欄位為唯讀。

System_CAPS_pubfieldSystem_CAPS_staticMinValue

代表 DateTime 最小的可能值。 此欄位為唯讀。

名稱描述
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

將指定的日期和時間加上指定的時間間隔,產生新的日期和時間。

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

判斷 DateTime 的兩個指定執行個體是否相等。

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

判斷某個指定的 DateTime 是否晚於另一個指定的 DateTime

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

判斷某個指定之 DateTime 表示的是同於還是晚於另一個指定之 DateTime 的日期和時間。

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

判斷 DateTime 的兩個指定執行個體是否不相等。

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

判斷某個指定的 DateTime 是否早於另一個指定的 DateTime

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

判斷某個指定之 DateTime 表示的是同於還是早於另一個指定之 DateTime 的日期和時間。

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

將另一個指定的日期和時間減去指定的日期和時間,並傳回時間間隔。

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

將指定的日期和時間減去指定的時間間隔,並傳回新的日期和時間。

名稱描述
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 傳回目前的 DateTime物件。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 將目前的 DateTime 物件轉換為指定類型的物件。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

此 API 支援 產品 基礎結構,而且不適合直接從程式碼使用。 不支援這個轉換。 嘗試使用這個方法會擲回 InvalidCastException

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

使用序列化目前 SerializationInfo 物件所需的資料,填入 DateTime 物件。

System_CAPS_note注意

若要檢視此類型的.NET Framework 原始程式碼,請參閱Reference Source 您可以瀏覽原始碼、 下載的參考,離線檢視,並逐步執行原始程式碼 (包含修補程式和更新),在偵錯;see instructions.

DateTime實值類型代表日期和時間值範圍介於 00:00:00 (午夜),年 1 月 1 日 0001 如下 (一般紀元) 到 11:59:59 P.M.年 12 月 31 到西元 9999年日(C.E.)西曆。

時間值會以稱為次滴答聲,100 奈秒為單位測量,並在特定日期是西元 1 日 0001年 12:00 午夜起的刻度數(C.E.)在GregorianCalendar行事曆 (不含會加入閏秒刻度為單位)。 例如,31241376000000000l 刻度值代表的日期,0100 年 1 月 01,星期五午夜 12:00:00。 ADateTime值一律表示在內容明確或預設的行事曆。

System_CAPS_note注意

如果您正在使用刻度值,您要轉換成某些其他時間間隔,例如分鐘或秒鐘,您應該使用TimeSpan.TicksPerDayTimeSpan.TicksPerHourTimeSpan.TicksPerMinuteTimeSpan.TicksPerSecond,或TimeSpan.TicksPerMillisecond常數,以執行轉換。 例如,若要加入的秒數表示所指定的刻度數Second元件DateTime值,您可以使用運算式dateValue.Second + nTicks/Timespan.TicksPerSecond

本節內容:

DateTime 物件具現化
日期時間值和其字串表示法
將字串轉換成日期時間值
版本的考量
日期時間值
DateTime 作業
日期時間解析
DateTime vs。TimeSpan
日期時間值和行事曆
保存的日期時間值
COM interop 的考量

您可以建立新DateTime任何下列方式的值︰

  • 藉由呼叫的多載的任何DateTime建構函式可讓您指定的日期和時間值 (例如年、 月和日或刻度數目) 的特定項目。 下列陳述式說明的其中一個呼叫DateTime建構函式來建立與特定年份、 月、 日、 小時、 分鐘和秒的日期。

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • 使用任何編譯器特有的語法來宣告日期和時間值。 例如,下列 Visual Basic 陳述式初始化新DateTime值。

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • 藉由指派DateTime物件屬性或方法傳回的日期和時間值。 下列範例會指派目前的日期和時間、 目前的國際標準時間 (UTC) 日期和時間,以及目前的日期到三個新DateTime變數。

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • 藉由剖析日期和時間值的字串表示。 ParseParseExactTryParse,和TryParseExact方法全都會將字串轉換為其相等的日期和時間值。 下列範例會使用Parse方法剖析字串,並將它轉換成DateTime值。

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

    請注意,TryParseTryParseExact方法指出特定的字串是否包含有效表示法DateTime除了執行轉換的值。

  • 藉由呼叫DateTime結構的隱含預設建構函式。 (如實值類型的隱含的預設建構函式的詳細資訊,請參閱實值類型 (C# 參考)。) 近似的同等權限,支援它,編譯器會宣告DateTime不含明確指派給它的日期和時間值。 下列範例說明呼叫DateTime隱含的預設建構函式,在 C# 和 Visual Basic 中,以及DateTime變數宣告,但在 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));
    

就內部而言,所有DateTime值會表示為 0001 年 1 月 1 日的 12:00:00 午夜以來已經過的刻度 (100 奈秒間隔數) 數目。 實際DateTime值無關時顯示在使用者介面項目,或寫入至檔案時,此值的顯示的方式。 外觀DateTime值是格式化作業結果。 格式化是將值轉換為其字串表示的程序。

因為日期和時間值的外觀會隨著文化特性、 國際標準、 應用程式需求和個人喜好,這類因素DateTime結構提供很大的彈性,格式化日期和時間值的多載透過其ToString方法。 預設值DateTime.ToString()方法會傳回使用目前文化特性的簡短日期和完整時間模式的日期和時間值的字串表示。 下列範例會使用預設DateTime.ToString()方法來顯示日期和時間的簡短日期和完整時間模式使用 EN-US 文化特性,在此範例執行所在電腦上目前的文化特性。

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)方法會傳回使用簡短日期和完整時間模式的特定文化特性的日期和時間值的字串表示。 下列範例會使用DateTime.ToString(IFormatProvider)方法來顯示日期和時間使用 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)方法傳回的字串表示的日期和時間格式是由標準或自訂格式規範定義並使用目前文化特性的格式化慣例。 下列範例會使用DateTime.ToString(String)方法,以顯示完整日期和時間模式的 EN-US 文化特性,在此範例執行所在電腦上目前的文化特性。

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)方法傳回的字串表示的日期和時間格式是由特定的格式規範定義並使用特定文化特性的格式化慣例。 下列範例會使用DateTime.ToString(String, IFormatProvider)方法,以顯示完整日期和時間模式的 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

如需有關格式DateTime值,請參閱標準日期和時間格式字串自訂日期和時間格式字串

剖析涉及將轉換的日期和時間的字串表示DateTime值。 一般而言,日期和時間字串的應用程式中都有兩個不同的使用方式︰

  • 它們代表的日期和時間,可以接受各種形式,以反映目前文化特性或特定文化特性的慣例。 比方說,應用程式可能會允許其目前的文化特性是 EN-US 輸入日期值為"12/15/2013"或"2013 年 12 月 15 日 」 的使用者,且允許 EN-GB 輸入日期值做為 「 15/12/2013 」 或 「 15 年 12 月 2013 」 會在目前文化特性的使用者。

  • 它們代表的日期和時間,以預先定義的格式。 例如,應用程式可以將"20130103 」 將日期序列化與在其執行應用程式,或它可能需要日期目前的文化特性的簡短日期格式輸入文化特性無關。

您可以使用ParseTryParse可能在反映文化特性所使用的一般日期和時間格式的其中一個的字串轉換方法DateTime值。 下列範例示範如何使用TryParse轉換數目不同文化特性特定格式的日期字串DateTime值。 目前的文化特性變更為 英文 (英國) 以及呼叫GetDateTimeFormats()方法來產生日期和時間字串的陣列。 接著,將每個項目陣列中要TryParse方法。 範例輸出會顯示剖析方法無法成功轉換每個特定文化特性的日期和時間字串。

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

您可以使用TryParseTryParseExact方法,將轉換的日期和時間的字串必須符合特定的格式或格式,以便DateTime值。 為參數,以剖析 methodby 使用一或多個或日期和時間格式字串中指定的所需的格式。 下列範例會使用TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)方法,將必須在 「 yyyyMMdd"格式或"HHmmss"格式的字串轉換DateTime值。

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

ParseParseExact方法擲回例外狀況,無法轉換成字串DateTime無法剖析值。 TryParseTryParseExact方法會傳回Boolean值,指出轉換成功或失敗。 因為在剖析作業的日期和時間字串,特別是如果輸入字串的使用者,通常會具有較高的失敗率,而且因為例外狀況處理成本很高,您應該使用TryParseTryParseExact其中效能非常重要,或轉換受限於失敗的比率較高的案例中的方法。

如需剖析日期和時間值的詳細資訊,請參閱在 .NET Framework 中剖析日期和時間字串

在.NET Framework 2.0 版之前DateTime結構包含串連具有私用未使用 2 位元欄位所組成的 64 位元欄位Ticks欄位,它是 62 位元不帶正負號的欄位,其中包含代表日期和時間的刻度數。Ticks欄位可以透過取得Ticks屬性。

從.NET Framework 2.0,DateTime結構包含 64 位元欄位與刻度欄位串連的私用類型欄位所組成。 [類型] 欄位是 2 位元欄位,指出是否DateTime結構代表本地時間、 國際標準時間 (UTC) 或未指定時區的時間。 [類型] 欄位可用來執行時間轉換在各時區間,而不是用於時間比較或算術。 [類型] 欄位的值可以透過取得Kind屬性。

System_CAPS_note注意

替代DateTime結構處理日期和時間值特別時區是DateTimeOffset結構。 DateTimeOffset結構會將日期和時間資訊儲存在私用DateTime欄位,依據該日期和時間的分鐘數與 UTC 差異大小的私用Int16欄位。 這可讓DateTimeOffset值,以反映為特定時區的時間,而DateTime只 UTC 和本機時區的時間,可以明確地反映值。 如需有關使用時機的討論DateTime結構或DateTimeOffset結構處理日期和時間值時,請參閱在 DateTime、DateTimeOffset、 TimeSpan 和 TimeZoneInfo 之間選擇

中的時間值的描述DateTime類型通常會使用 Coordinated Universal Time (UTC) 標準,也就是格林威治標準時間 (GMT) 的國際認可的名稱來表示。 國際標準時間是在 UTC 原點零度經度測量的時間。 不適用 UTC 日光節約時間。

本地時間為相對於特定的時區。 時區是時區的相關聯時區時差,以小時為單位的 UTC 原點時間的開始位移。 此外,日光節約時間,加上或減去一天的長度從一小時的選擇會影響本地時間。 因此,本機時間計算方式是將時區時差 UTC 和必要的日光節約時間調整。 UTC 原點的時區位移為零。

UTC 時間為適用於計算、 比較,並儲存日期和時間的檔案。 本地時間為適當的桌面應用程式的使用者介面中顯示的資料。 時區感知應用程式 (例如許多 Web 應用程式) 也需要處理一些其他的時區。

如果Kind屬性DateTime物件是DateTimeKind.Unspecified,是未指定表示的時間是否本地時間、 UTC 時間或某些其他時區的時間。

計算使用DateTime結構,例如AddSubtract,不會修改結構的值。 相反地,傳回新的計算DateTime結構,其值會計算的結果。

時區 (例如 UTC 與本地時間,或是一個時區,另一個之間) 之間的轉換作業會將日光節約時間列入考量,但算術和比較作業不這麼做。

DateTime結構本身提供有限的支援從一個時區轉換。 您可以使用ToLocalTime方法來轉換 UTC 到本地時間,或者您可以使用ToUniversalTime方法從本地時間轉換為 UTC。 不過,一組完整的時區轉換方法,可以在TimeZoneInfo類別。 使用這些方法,您可以將任何一種全世界的時區的時間轉換為任何其他時區的時間。

計算和比較DateTime物件才有意義的物件都代表在相同時區的時間。 您可以使用TimeZoneInfo物件以代表DateTime區域值的時間,雖然兩種鬆散耦合。 (也就是說,DateTime物件沒有屬性,可傳回物件,表示該日期和時間值的時區以外Kind屬性。) 基於這個理由,在時區感知應用程式中,您必須依賴某種外部機制來判斷所在時區DateTime建立物件。 例如,您可以使用包裝兩者的結構DateTime值和TimeZoneInfo物件,代表DateTime值的時區。 如需詳細資訊,在計算和比較中使用 UTCDateTime值,請參閱使用日期和時間執行算術運算

每個DateTime成員以隱含方式來執行其作業,除了指定行事曆,建構函式使用西曆和方法的參數衍生自IFormatProvider,例如System.Globalization.DateTimeFormatInfo,隱含地指定行事曆。

作業的成員DateTime類型納入帳戶詳細資料,例如潤年和月中的天數。

兩個其他常見作業使用DateTime值牽涉到將轉換的日期和時間值,或從其字串表示法。 轉換的程序DateTime為其字串表示的值執行格式化作業; 如需格式的詳細資訊,請參閱日期時間值和其字串表示法 轉換的日期和時間的字串表示的程序DateTime值是在剖析作業; 如需剖析的詳細資訊,請參閱將字串轉換成日期時間值

System_CAPS_note注意

做為執行日期和時間運算上替代DateTime值測量已耗用時間,您可以使用Stopwatch類別。

Ticks屬性表示的日期和時間值的第二個,一個 10-百萬分之一秒為單位而Millisecond屬性會傳回千分之一秒的日期和時間值中。 不過,如果您使用重複的呼叫DateTime.Now屬性,以測量經歷的時間,和您關心小於 100 毫秒的短暫間隔,您應該注意傳回的值DateTime.Now屬性是相依於系統時鐘,其在 Windows 7 和 Windows 8 的系統上具有的解析度大約 15 毫秒。

下列範例說明目前日期和時間值的相依的性,根據系統時鐘的解析度。 在範例中,外部迴圈會重複 20 倍,而且內部迴圈是用來延遲外部迴圈。 如果外部迴圈計數器的值是 10,呼叫Thread.Sleep方法會導入了 5 毫秒的延遲。 範例輸出所示,所傳回的毫秒數DateTime.Now.Milliseconds屬性只有在呼叫之後變更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

DateTimeTimeSpan實值型別的差別在於DateTime表示時間的瞬間而TimeSpan表示時間間隔。 這表示,例如,您可以將一個執行個體減去DateTime從另一個取得TimeSpan物件,表示它們之間的時間間隔。 或者您可以增加正TimeSpan目前DateTime取得DateTime表示未來的日期值。

您可以加入或減去的時間間隔DateTime物件。 時間間隔可以是負數或正數,可以用來表示單位,如刻度或秒數,或可以表示為TimeSpan物件。

.NET Framework 類別庫包含數個行事曆類別,全部都是衍生自Calendar類別。 包括:

每個文化特性會使用預設的行事曆,定義其唯讀CultureInfo.Calendar屬性,並支援一或多個日曆定義其唯讀CultureInfo.OptionalCalendars屬性。 目前由特定的行事曆CultureInfo物件由定義其DateTimeFormatInfo.Calendar屬性; 它必須是其中一個中找到的行事曆CultureInfo.OptionalCalendars陣列。

文化特性的現行曆法用於所有文化特性的格式化作業。 例如,波斯文 (伊朗) 文化特性的預設曆法是 um al Qura 曆法由UmAlQuraCalendar類別。CultureInfo用於表示波斯文 (伊朗) 文化特性物件的日期和時間格式的作業,um al Qura 曆法由預設值,並用西曆才文化特性的DateTimeFormatInfo.Calendar屬性變更,如下列範例所示。

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

文化特性的現行曆法也用於所有的剖析作業,該文化特性,如下列範例所示。

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

您也可以執行個體化DateTime藉由呼叫使用日期和時間的項目 (例如年、 月和日的數字) 特定的行事曆值DateTime 建構函式包含calendar參數,並將其傳遞Calendar物件,表示該行事曆。 下列範例會使用日期和時間的項目從UmAlQuraCalendar行事曆。

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

DateTime建構函式不包含calendar參數假設的日期和時間的項目以西曆中的單位表示。

所有其他DateTime屬性和方法使用西曆。 例如,DateTime.Year屬性西曆,傳回年份和DateTime.IsLeapYear(Int32)方法會假設year參數是西曆年份。 每個DateTime使用西曆的成員都有對應的成員Calendar使用特定曆法類別。 例如,Calendar.GetYear方法會傳回特定曆法,年份和Calendar.IsLeapYear方法解譯year參數中特定曆法的年數字。 下列範例同時使用DateTime和對應的成員的UmAlQuraCalendar類別。

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

雖然DateTime結構包含DayOfWeek傳回一週天數西曆中的屬性,它不包含可讓您擷取一年的週數的成員。 若要擷取的年度週次,呼叫個別的行事曆Calendar.GetWeekOfYear方法。 下列範例提供一個實例。

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

如需有關日期和行事曆的詳細資訊,請參閱使用行事曆

您可以保存DateTime四種方式中的值︰

不論您選擇哪一種技術,您必須確保還原的常式DateTime值不會遺失資料,或擲回例外狀況。 DateTime值應該反覆存取。 也就是原始的值與已還原的值應相同。 如果原始DateTime值代表單一時刻,它應該識別的時間還原時相同的時間。

已成功還原DateTime值保存為字串,請遵循這些規則︰

最常見的錯誤進行保存時DateTime依賴預設值或目前的文化特性的格式化慣例是以字串形式的值。 如果目前的文化特性不同儲存及還原字串時,會發生問題。 下列範例會說明這些問題。 它會將儲存五個使用在此案例中是英文 (美國) 的目前文化特性的格式化慣例的日期。 還原使用在此案例中是英文 (英國) 的目前文化特性的格式化慣例的日期。 因為不同的兩個文化特性的格式化慣例,無法還原兩個日期,以及剩餘的三個日期的不正確地解譯。 此外,如果原始的日期和時間值代表單一時間的還原時間不正確,因為時區資訊將會遺失。

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

若要反覆存取DateTime值已成功,請遵循下列步驟︰

  1. 如果值代表單一分鐘的時間,將它們轉換從本地時間到 UTC 藉由呼叫ToUniversalTime方法。

  2. 將日期轉換成其字串表示法中,藉由呼叫ToString(String, IFormatProvider)String.Format(IFormatProvider, String, Object[])多載。 藉由指定使用的文化特性而異的格式設定慣例CultureInfo.InvariantCultureprovider引數。 指定使用"O"或"R"應該反覆存取值。

  3. 當您呼叫Parse(String, IFormatProvider, DateTimeStyles)TryParse(String, IFormatProvider, DateTimeStyles, DateTime)方法。

若要還原的保存DateTime值不會遺失資料,執行下列動作︰

  1. 剖析資料,藉由呼叫ParseExactTryParseExact多載。 指定CultureInfo.InvariantCultureprovider引數,並使用相同的標準格式字串的format轉換期間的引數。 包含DateTimeStyles.RoundtripKindstyles引數。

  2. 如果DateTime值代表在時間中,呼叫的單一時刻ToLocalTime方法來轉換本地時間與 utc 之間的已剖析的日期。

下列範例會使用而異的文化特性和"O"標準格式字串,確保DateTime所儲存及還原的值代表不論系統、 文化特性或來源和目標系統的時區時間在同一時間。

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

而不是保存DateTime值為字串時,您可以將它做為保存Int64值代表微秒刻度數。 在此情況下,您不需要考慮的系統文化特性DateTime值會保存,並且上還原。

保存DateTime為整數的值︰

  • 如果DateTime代表單一時間的值,將它們轉換成 UTC 藉由呼叫ToUniversalTime方法。

  • 擷取所表示之刻度數DateTime值從其Ticks屬性。

若要還原DateTime已保存為整數的值︰

  1. 具現化新DateTime物件,並傳遞Int64值設定為DateTime(Int64)建構函式。

  2. 如果DateTime值代表單一時間點,將它從轉換 UTC 與本地時間藉由呼叫ToLocalTime方法。

下列範例會保存陣列DateTime值做為在美國太平洋時區系統上的整數。 UTC 時區系統上還原它。 包含整數的檔案包含Int32值,指出總數Int64緊接著它的值。

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

而不是儲存DateTime值做為字串或整數,接著,您必須轉換回DateTime值,您可以保存DateTime值透過序列化到資料流或檔案,然後再還原它們透過還原序列化。 在此情況下,DateTime某些指定的物件格式序列化資料,並將物件還原序列化時還原。 格式器或序列化程式,例如XmlSerializerBinaryFormatter,處理的序列化和還原序列化程序。 如需序列化和.NET Framework 所支援的序列化類型的詳細資訊,請參閱序列化

下列範例會使用XmlSerializer類別來序列化和還原序列化DateTime值,表示所有 leap 第二十一世紀的年份天。 如果目前文化特性是英文 (英國) 的系統上執行此範例輸出會表示結果。 因為我們已經還原序列化DateTime物件本身的程式碼不需要處理日期和時間格式的文化特性差異。

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

上述範例未包含時間資訊。 不過,如果DateTime值代表時間點,而且以本地時間表示,您應該將它轉換從本地時間到 UTC 之前序列化藉由呼叫ToUniversalTime方法。 將它還原序列化之後,您應該將它轉換 UTC 從本地時間藉由呼叫ToLocalTime方法。 下列範例會使用BinaryFormatter類別來序列化DateTime在美國太平洋時區系統上的資料太平洋標準時間區域,並將它還原序列化 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...

先前的範例是所有假設DateTime值會以本地時間表示,轉換 UTC 與本地時間之間的值,讓它們反映在來源和目標系統上的相同時間點。 DateTime值可能也會反映在 local 以外的時區與 UTC 時間。 在此情況下,因為DateTime結構不是時區感知,您必須同時序列化DateTime值和TimeZoneInfo代表時區的物件。 若要這樣做,建立同時包含其欄位的型別DateTime值和時區。 下列範例會定義DateWithTimeZone說明如何這可能會完成的結構。

using System;

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

      public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
      {
         dt = dateValue;
         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_important重要

DateWithTimeZone結構用於下面兩個範例,可以序列化和還原序列化的陣列DateWithTimeZone物件。 若要執行的範例,先建立類別庫包含DateWithTimeZone結構,然後再加入它的參考,當您編譯每個範例。

使用DateWithTimeZone結構,您可以再保存日期和時間以及時區資訊。 下列範例會使用BinaryFormatter類別來序列化的陣列DateWithTimeZone物件。

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

下列範例會接著呼叫BinaryFormatter.Deserialize方法來加以還原序列化。

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

ADateTime轉移到 COM 應用程式,然後傳送到受管理的應用程式,值稱為往返。 不過,DateTime值,指定的時間並不會如您預期反覆存取。

如果您來回只有時間,例如下午 3 」,最後的日期和時間是 30,1899 年西元下午 3:00,而不是 年 1 月 1 日公元 0001 下午 3:00這是因為.NET Framework 和 COM 假設預設的日期時指定的時間。 不過,COM 系統會假設 1899 年 12 月 30 日西元基底日期時.NET Framework 假設基底日期的年 1 月 1 日公元 0001

當只有時間從.NET Framework 傳遞至 COM 時,特殊的處理會執行,將時間轉換成 COM 所使用的格式 當只有一次從 COM 傳遞至.NET Framework 時,合法的日期和時間或 1899 年 12 月 30 日之前會損毀,因為不執行任何特殊處理。 這也表示如果日期開始其來回從 COM,.NET Framework 和 COM 保留日期。

.NET Framework 和 COM 的行為表示,如果您的應用程式往返DateTime,只指定時間,您的應用程式必須記得來修改或忽略錯誤的日期,從最後DateTime物件。

下列範例示範如何比較大致相等DateTime宣告它們相等時接受差異小邊界的值。

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

通用 Windows 平台
自 8 起供應
.NET Framework
自 1.1 起供應
可攜式類別庫
提供支援︰ 可攜式 .NET 平台
Silverlight
自 2.0 起供應
Windows Phone Silverlight
自 7.0 起供應
Windows Phone
自 8.1 起供應

這個型別的所有成員都是安全執行緒。 修改執行個體狀態會顯示的成員實際上會傳回新的值初始化的新執行個體。 做為任何其他類型,以讀取和寫入至共用的變數,其中包含此類型的執行個體必須受到鎖定來保證的執行緒安全。

System_CAPS_caution注意

指派此類型的執行個體不是安全執行緒上所有的硬體平台因為該執行個體的二進位表示法可能太大,無法在單一不可部分完成的作業中指定。

回到頁首
顯示: