本文由机器翻译。若要查看英语原文,请勾选“英语”复选框。 也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

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)

返回一个值,该值指示此实例是否等于指定的对象。(覆盖 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 自动化日期等效的 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 值的指示,指定为本地时间或协调世界时 (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 对象的值转换为其等效的长日期字符串表示形式。

System_CAPS_pubmethodToLongTimeString()

将当前 DateTime 对象的值转换为其等效的长时间字符串表示形式。

System_CAPS_pubmethodToOADate()

将此实例的值转换为等效的 OLE 自动化日期。

System_CAPS_pubmethodToShortDateString()

将当前 DateTime 对象的值转换为其等效的短日期字符串表示形式。

System_CAPS_pubmethodToShortTimeString()

将当前 DateTime 对象的值转换为其等效的短时间字符串表示形式。

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 PM,通过使用到公元 9999 年 12 月 31 日(C.E.)在公历日历中。

时间值以调用个时钟周期的 100 毫微秒为单位进行衡量和特定日期是自午夜 12:00 到公元 0001 年 1 月 1 日以来的计时周期数(C.E.)在GregorianCalendar日历 (不包括将添加闰秒的刻度)。 例如,刻度值 31241376000000000l 表示的日期,星期五,年 1 月 0100 日午夜 12:00:00。 ADateTime值始终表示中的上下文显式或默认日历。

System_CAPS_note说明

如果你正在使用计时周期值是否想要转换为其他时间间隔,如分钟或秒,应使用TimeSpan.TicksPerDayTimeSpan.TicksPerHourTimeSpan.TicksPerMinuteTimeSpan.TicksPerSecond,或TimeSpan.TicksPerMillisecond常量,以执行转换。 例如,若要添加的秒数表示通过指定到的计时周期数Second组件的DateTime值,你可以使用表达式dateValue.Second + nTicks/Timespan.TicksPerSecond

本节内容:

实例化一个 DateTime 对象
DateTime 值和其字符串表示形式
将字符串转换为日期时间值
版本注意事项
日期时间值
DateTime 操作
DateTime 解析
DateTime vs。TimeSpan
日期时间值和日历
保留日期时间值
COM 互操作注意事项

你可以创建一个新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而无需显式将日期和时间分配给它的值。 下面的示例演示调用DateTimeC# 和 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 输入的日期值为"2013 年 12 月 15 日"或"2013 年 12 月 15 日",并允许其当前区域性 EN-GB 输入的日期值为"12/15/2013"或"2013 15 年 12 月"的用户。

  • 它们表示的日期和时间的预定义的格式。 例如,应用程序可能将序列化的日期"20130103"为独立于在其应用正在运行,或它可能需要日期作为输入当前区域性的短日期格式的区域性。

你可以使用ParseTryParse方法将可能反映到区域性使用的常见日期和时间格式之一的 string 转换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 位字段。 Kind 字段是一个 2 位字段,该值指示是否DateTime结构表示本地时间、 协调世界时 (UTC) 或在未指定时区的时间。 执行时间转换之间的时区,而不是时间比较或算术时,使用类型的字段。 类型的字段的值可以通过获取Kind属性。

System_CAPS_note说明

一种替代方法DateTime结构使用的日期和时间值中特定时区为DateTimeOffset结构。 DateTimeOffset结构将日期和时间信息存储在私有DateTime字段和依据该日期和时间的分钟数与 UTC 的差异在私有Int16字段。 这样便能为DateTimeOffset值以反映特定时区中的时间,而DateTime仅 UTC 和本地时区的时间,可以明确地反映值。 有关何时使用讨论DateTime结构或DateTimeOffset结构使用日期和时间值时,请参阅在 DateTime、DateTimeOffset、TimeSpan 和 TimeZoneInfo 之间进行选择

中的时间值的说明DateTime类型通常表示使用协调世界时 (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 值和其字符串表示形式 将转换的字符串表示形式的日期和时间的过程DateTime值是分析操作; 有关分析的详细信息,请参阅将字符串转换为日期时间值

System_CAPS_note说明

作为执行日期和时间运算上的替代方法DateTime值来测量运行时间,你可以使用Stopwatch类。

Ticks属性表示日期和时间值的一秒的一千万分之一单位和Millisecond属性中的日期和时间值返回分之几秒。 但是,如果将重复的调用DateTime.Now属性测量已用的时间和您担心较短时间间隔小于 100 毫秒,你应记下返回值DateTime.Now属性都依赖于系统时钟,它在 Windows 7 和 Windows 8 的系统上具有的分辨率大约 15 毫秒。

下面的示例演示当前日期和时间值的依赖于系统时钟的分辨率。 在示例中,将外部循环重复 20 倍,并且内部循环用于延迟外部循环。 如果外部循环计数器的值为 10,调用Thread.Sleep方法引入了五个毫秒延迟。 如示例输出所示,返回的千分之几秒数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.InvariantCulture作为provider自变量。 指定的值应通过使用"O"或"R"往返。

  3. 当调用Parse(String, IFormatProvider, DateTimeStyles)TryParse(String, IFormatProvider, DateTimeStyles, DateTime)方法。

若要还原的保留DateTime值而不丢失数据,执行以下操作︰

  1. 通过调用分析的数据ParseExactTryParseExact重载。 指定CultureInfo.InvariantCulture作为provider自变量,并使用相同的标准格式字符串用于format转换期间的自变量。 包括DateTimeStyles.RoundtripKind中的值styles自变量。

  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值还可能反映中而不是本地的时区与 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 年 12 月公元下午 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小心

分配此类型的实例不线程在所有硬件平台上安全,因为该实例的二进制表示形式可能太大,无法在单个原子操作中分配。

返回页首
显示: