DateTime dt = new DateTime(2008, 5, 1, 8, 30, 52,001); //正確

 DateTime dt = new DateTime();  

dt.Year = 2008;//錯誤  Year 是隻讀屬性，DateTime 不根據該方式給年月日等賦值。

可以用強轉,
DateTime d = DateTime.Parse("2010-2-12");
或者是建立新的例項
DateTime dd = new DateTime(2010, 2, 12);
 new DateTime(2010, 2, 12);
這個的引數有好多,也可以自定義小時,分,秒,

DateTime now = DateTime.Now;
Console.WriteLine(now.ToString("yyyy-MM-dd"));  //按yyyy-MM-dd格式輸出s

Console.WriteLine(dt.ToString());    //  26/11/2009 AM 11:21:30

Console.WriteLine(dt.ToFileTime().ToString());   //   129036792908014024

// Converts the value of the current System.DateTime object to a Windows file time 

Console.WriteLine(dt.ToFileTimeUtc().ToString());  //     129036792908014024

// Converts the value of the current System.DateTime object to a Windows file time

Console.WriteLine(dt.ToLocalTime().ToString());   //       26/11/2009 AM 11:21:30

// Converts the value of the current System.DateTime object to local time.

Console.WriteLine(dt.ToLongDateString().ToString());   //      2009年11月26日

Console.WriteLine(dt.ToLongTimeString().ToString());  //      AM 11:21:30

Console.WriteLine(dt.ToOADate().ToString());   //      40143.4732731597

Console.WriteLine(dt.ToShortDateString().ToString());   //     26/11/2009

Console.WriteLine(dt.ToShortTimeString().ToString());   //     AM 11:21

Console.WriteLine(dt.ToUniversalTime().ToString());   //       26/11/2009 AM 3:21:30

Console.WriteLine(dt.Year.ToString());   //        2009

Console.WriteLine(dt.Date.ToString());   //        26/11/2009 AM 12:00:00

Console.WriteLine(dt.DayOfWeek.ToString());  //       Thursday

Console.WriteLine(dt.DayOfYear.ToString());   //       330

Console.WriteLine(dt.Hour.ToString());       //        11

Console.WriteLine(dt.Millisecond.ToString());   //     801        （毫秒）

Console.WriteLine(dt.Minute.ToString());   //      21

Console.WriteLine(dt.Month.ToString());   //       11

Console.WriteLine(dt.Second.ToString());   //      30

Console.WriteLine(dt.Ticks.ToString());   //       633948312908014024


Console.WriteLine(dt.TimeOfDay.ToString());   //       12:29:51.5181524

// Gets the time of day for this instance.

// 返回 A System.TimeSpan that represents the fraction of the day that has elapsed since midnight.

Console.WriteLine(dt.ToString());     //     26/11/2009 PM 12:29:51

Console.WriteLine(dt.AddYears(1).ToString());    //         26/11/2010 PM 12:29:51

Console.WriteLine(dt.AddDays(1.1).ToString());    //        27/11/2009 PM 2:53:51

Console.WriteLine(dt.AddHours(1.1).ToString());    //       26/11/2009 PM 1:35:51

Console.WriteLine(dt.AddMilliseconds(1.1).ToString());    //26/11/2009 PM 12:29:51

Console.WriteLine(dt.AddMonths(1).ToString());    //        26/12/2009 PM 12:29:51

Console.WriteLine(dt.AddSeconds(1.1).ToString());    //     26/11/2009 PM 12:29:52

Console.WriteLine(dt.AddMinutes(1.1).ToString());    //     26/11/2009 PM 12:30:57

Console.WriteLine(dt.AddTicks(1000).ToString());    //      26/11/2009 PM 12:29:51

Console.WriteLine(dt.CompareTo(dt).ToString());    //       0

Console.WriteLine(dt.Add(new TimeSpan(1,0,0,0)).ToString());    // 加上一個時間段

（注：

System.TimeSpan為一個時間段，建構函式如下

public TimeSpan(long ticks); // ticks: A time period expressed in 100-nanosecond units.

                           //nanosecond：十億分之一秒   new TimeSpan(10,000,000)        為一秒

public TimeSpan(int hours, int minutes, int seconds);

public TimeSpan(int days, int hours, int minutes, int seconds);

public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds);

）
Console.WriteLine(dt.Equals("2005-11-6 16:11:04").ToString());     //        False

Console.WriteLine(dt.Equals(dt).ToString());    //      True

Console.WriteLine(dt.GetHashCode().ToString());    //       1103291775

Console.WriteLine(dt.GetType().ToString());    //       System.DateTime

Console.WriteLine(dt.GetTypeCode().ToString());    //       DateTime
  

long Start = Environment.TickCount;   //單位是毫秒

long End = Environment.TickCount;

Console.WriteLine("Start is : "+Start);

Console.WriteLine("End is : "+End);

Console.WriteLine("The Time is {0}",End-Start);
Console.WriteLine(dt.GetDateTimeFormats('s')[0].ToString());    //2009-11-26T13:29:06

Console.WriteLine(dt.GetDateTimeFormats('t')[0].ToString());    //PM 1:29

Console.WriteLine(dt.GetDateTimeFormats('y')[0].ToString());    //2009年11月

Console.WriteLine(dt.GetDateTimeFormats('D')[0].ToString());    //2009年11月26日

Console.WriteLine(dt.GetDateTimeFormats('D')[1].ToString());    //星期四, 26 十一月, 2009

Console.WriteLine(dt.GetDateTimeFormats('D')[2].ToString());    //26 十一月, 2009

Console.WriteLine(dt.GetDateTimeFormats('D')[3].ToString());    //星期四 2009 11 26

Console.WriteLine(dt.GetDateTimeFormats('M')[0].ToString());    //26 十一月

Console.WriteLine(dt.GetDateTimeFormats('f')[0].ToString());    //2009年11月26日 PM 1:29

Console.WriteLine(dt.GetDateTimeFormats('g')[0].ToString());    //26/11/2009 PM 1:29

Console.WriteLine(dt.GetDateTimeFormats('r')[0].ToString());    //Thu, 26 Nov 2009 13:29:06 GMT

(注：

常用的日期時間格式：

格式 說明      輸出格式 
d 精簡日期格式 MM/dd/yyyy 
D 詳細日期格式 dddd, MMMM dd, yyyy 
f  完整格式    (long date + short time) dddd, MMMM dd, yyyy HH:mm 
F 完整日期時間格式 (long date + long time) dddd, MMMM dd, yyyy HH:mm:ss 
g 一般格式 (short date + short time) MM/dd/yyyy HH:mm 
G 一般格式 (short date + long time) MM/dd/yyyy HH:mm:ss 
m,M 月日格式 MMMM dd 
s 適中日期時間格式 yyyy-MM-dd HH:mm:ss 
t 精簡時間格式 HH:mm 
T 詳細時間格式 HH:mm:ss

)


Console.WriteLine(string.Format("{0:d}", dt));    //28/12/2009

Console.WriteLine(string.Format("{0:D}", dt));    //2009年12月28日

Console.WriteLine(string.Format("{0:f}", dt));    //2009年12月28日 AM 10:29

Console.WriteLine(string.Format("{0:F}", dt));    //2009年12月28日 AM 10:29:18

Console.WriteLine(string.Format("{0:g}", dt));    //28/12/2009 AM 10:29

Console.WriteLine(string.Format("{0:G}", dt));    //28/12/2009 AM 10:29:18

Console.WriteLine(string.Format("{0:M}", dt));    //28 十二月

Console.WriteLine(string.Format("{0:R}", dt));    //Mon, 28 Dec 2009 10:29:18 GMT

Console.WriteLine(string.Format("{0:s}", dt));    //2009-12-28T10:29:18

Console.WriteLine(string.Format("{0:t}", dt));    //AM 10:29

Console.WriteLine(string.Format("{0:T}", dt));    //AM 10:29:18

Console.WriteLine(string.Format("{0:u}", dt));    //2009-12-28 10:29:18Z

Console.WriteLine(string.Format("{0:U}", dt));    //2009年12月28日 AM 2:29:18

Console.WriteLine(string.Format("{0:Y}", dt));    //2009年12月

Console.WriteLine(string.Format("{0}", dt));    //28/12/2009 AM 10:29:18

Console.WriteLine(string.Format("{0:yyyyMMddHHmmssffff}", dt));    //200912281029182047

計算2個日期之間的天數差
DateTime dt1 = Convert.ToDateTime("2007-8-1");    
DateTime dt2 = Convert.ToDateTime("2007-8-15");   
TimeSpan span = dt2.Subtract(dt1);              
int dayDiff = span.Days ;                    

計算某年某月的天數
int days = DateTime.DaysInMonth(2009, 8);       
days = 31;                                      

給日期增加一天、減少一天
DateTime dt =DateTime.Now;
dt.AddDays(1); //增加一天 dt本身並不改變
dt.AddDays(-1);//減少一天 dt本身並不改變

 

DateTime   dt1   =   DateTime.Now;   
  DateTime   dt2   =   DateTime.Now.AddDays(-7);   
  TimeSpan   ts   =   dt1   -   dt2;   
    
  int   days   =   ts.Days;   //dt1和dt2相差多少天

eg2.
     //編輯月份和系統登入月份是否相等
     if(Convert.ToDateTime(DateTime.Now.ToShortDateString()).Month==Convert.ToDateTime(this.GetQueryString("sdate")).Month)
     {
      TimeSpan  ts=Convert.ToDateTime(DateTime.Now.ToShortDateString())-Convert.ToDateTime(this.GetQueryString("sdate"));
      iDays=ts.Days;
      //登入系統的前三天可以編輯
      if(iDays<4)
      {
       Submiter submit = new Submiter(this,"tt");
       this.iseretail.SelectedValue=this.GetQueryString("rid");
       this.txtTime.Text=this.GetQueryString("sdate").ToString();
       this.InputSelect1.WhereCondition=" gxlshd='"+this.GetQueryString("rid")+"'";
       if(this.GetQueryString("workid")!="")
        this.InputSelect1.SelectedValue=this.GetQueryString("workid");
       submit.InitInsertMode();
       SetDataGrid();
      }
      eg3.C#中計算兩個時間的差

 /// <summary>
        /// 計算兩個日期的時間間隔
        /// </summary>
        /// <param name="DateTime1">第一個日期和時間</param>
        /// <param name="DateTime2">第二個日期和時間</param>
        /// <returns></returns>
        private string DateDiff(DateTime DateTime1, DateTime DateTime2)
        {
            string dateDiff = null;
            
            TimeSpan ts1 = new TimeSpan(DateTime1.Ticks);
            TimeSpan ts2 = new TimeSpan(DateTime2.Ticks);
            TimeSpan ts = ts1.Subtract(ts2).Duration();
            dateDiff = ts.Days.ToString()+"天"
                + ts.Hours.ToString()+"小時"
                + ts.Minutes.ToString()+"分鐘"
                + ts.Seconds.ToString()+"秒";
            
            return dateDiff;
        }說明：
1.DateTime值型別代表了一個從公元0001年1月1日0點0分0秒到公元9999年12月31日23點59分59秒之間的具體日期時刻。因此，你可以用DateTime值型別來描述任何在想象範圍之內的時間。一個DateTime值代表了一個具體的時刻
2.TimeSpan值包含了許多屬性與方法，用於訪問或處理一個TimeSpan值
下面的列表涵蓋了其中的一部分：
Add：與另一個TimeSpan值相加。 
Days:返回用天數計算的TimeSpan值。 
Duration:獲取TimeSpan的絕對值。 
Hours:返回用小時計算的TimeSpan值 
Milliseconds:返回用毫秒計算的TimeSpan值。 
Minutes:返回用分鐘計算的TimeSpan值。 
Negate:返回當前例項的相反數。 
Seconds:返回用秒計算的TimeSpan值。 
Subtract:從中減去另一個TimeSpan值。 
Ticks:返回TimeSpan值的tick數。 
TotalDays:返回TimeSpan值表示的天數。 
TotalHours:返回TimeSpan值表示的小時數。 
TotalMilliseconds:返回TimeSpan值表示的毫秒數。 
TotalMinutes:返回TimeSpan值表示的分鐘數。 
TotalSeconds:返回TimeSpan值表示的秒數。 

 

見：

#region 程式集 mscorlib.dll, v4.0.0.0
// C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion

using System.Globalization;
using System.Runtime;
using System.Runtime.Serialization;
using System.Security;

namespace System
{
    // 摘要:
    //     表示時間上的一刻，通常以日期和當天的時間表示。
    [Serializable]
    public struct DateTime : IComparable, IFormattable, IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>
    {
        // 摘要:
        //     表示 System.DateTime 的最大可能值。 此欄位為只讀。
        public static readonly DateTime MaxValue;
        //
        // 摘要:
        //     表示 System.DateTime 的最小可能值。 此欄位為只讀。
        public static readonly DateTime MinValue;

        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定的刻度數。
        //
        // 引數:
        //   ticks:
        //     一個日期和時間，自公曆 0001 年 1 月 1 日 00:00:00.000 以來所經歷的以 100 納秒為間隔的間隔數來表示。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     ticks 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime(long ticks);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定的計時週期數以及協調世界時 (UTC) 或本地時間。
        //
        // 引數:
        //   ticks:
        //     一個日期和時間，自公曆 0001 年 1 月 1 日 00:00:00.000 以來所經歷的以 100 納秒為間隔的間隔數來表示。
        //
        //   kind:
        //     列舉值之一，指示 ticks 是指定了本地時間、協調世界時 (UTC)，還是兩者皆未指定。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     ticks 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        //
        //   System.ArgumentException:
        //     kind 不是 System.DateTimeKind 值之一。
        public DateTime(long ticks, DateTimeKind kind);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定的年、月和日。
        //
        // 引數:
        //   year:
        //     年（1 到 9999）。
        //
        //   month:
        //     月（1 到 12）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。 - 或 - month 小於 1 或大於 12。 - 或 - day 小於 1 或大於 month 中的天數。
        public DateTime(int year, int month, int day);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定日曆的指定年、月和日。
        //
        // 引數:
        //   year:
        //     年（1 到 calendar 中的年數）。
        //
        //   month:
        //     月（1 到 calendar 中的月數）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   calendar:
        //     用於解釋 year、month 和 day 的日曆。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     calendar 為 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     year 不在 calendar 所支援的範圍內。 - 或 - month 小於 1 或大於 calendar 中的月數。 - 或 - day 小於
        //     1 或大於 month 中的天數。
        public DateTime(int year, int month, int day, Calendar calendar);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定的年、月、日、小時、分鐘和秒。
        //
        // 引數:
        //   year:
        //     年（1 到 9999）。
        //
        //   month:
        //     月（1 到 12）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。 - 或 - month 小於 1 或大於 12。 - 或 - day 小於 1 或大於 month 中的天數。
        //     - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 - second 小於 0 或大於 59。
        public DateTime(int year, int month, int day, int hour, int minute, int second);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定日曆的指定年、月、日、小時、分鐘和秒。
        //
        // 引數:
        //   year:
        //     年（1 到 calendar 中的年數）。
        //
        //   month:
        //     月（1 到 calendar 中的月數）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   calendar:
        //     用於解釋 year、month 和 day 的日曆。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     calendar 為 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     year 不在 calendar 所支援的範圍內。 - 或 - month 小於 1 或大於 calendar 中的月數。 - 或 - day 小於
        //     1 或大於 month 中的天數。 - 或 - hour 小於 0 或大於 23 - 或 - minute 小於 0 或大於 59。 - 或 -
        //     second 小於 0 或大於 59。
        public DateTime(int year, int month, int day, int hour, int minute, int second, Calendar calendar);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定年、月、日、小時、分鐘、秒和協調世界時 (UTC) 或本地時間。
        //
        // 引數:
        //   year:
        //     年（1 到 9999）。
        //
        //   month:
        //     月（1 到 12）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   kind:
        //     列舉值之一，該值指示 year、month、day、hour、minute 和 second 指定了本地時間、協調世界時 (UTC)，還是兩者皆未指定。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。 - 或 - month 小於 1 或大於 12。 - 或 - day 小於 1 或大於 month 中的天數。
        //     - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 - second 小於 0 或大於 59。
        //
        //   System.ArgumentException:
        //     kind 不是 System.DateTimeKind 值之一。
        public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定的年、月、日、小時、分鐘、秒和毫秒。
        //
        // 引數:
        //   year:
        //     年（1 到 9999）。
        //
        //   month:
        //     月（1 到 12）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   millisecond:
        //     毫秒（0 到 999）。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。 - 或 - month 小於 1 或大於 12。 - 或 - day 小於 1 或大於 month 中的天數。
        //     - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 - second 小於 0 或大於 59。
        //     - 或 - millisecond 小於 0 或大於 999。
        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定日曆的指定年、月、日、小時、分鐘、秒和毫秒。
        //
        // 引數:
        //   year:
        //     年（1 到 calendar 中的年數）。
        //
        //   month:
        //     月（1 到 calendar 中的月數）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   millisecond:
        //     毫秒（0 到 999）。
        //
        //   calendar:
        //     用於解釋 year、month 和 day 的日曆。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     calendar 為 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     year 不在 calendar 所支援的範圍內。 - 或 - month 小於 1 或大於 calendar 中的月數。 - 或 - day 小於
        //     1 或大於 month 中的天數。 - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 -
        //     second 小於 0 或大於 59。 - 或 - millisecond 小於 0 或大於 999。
        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定年、月、日、小時、分鐘、秒、毫秒和協調世界時 (UTC) 或本地時間。
        //
        // 引數:
        //   year:
        //     年（1 到 9999）。
        //
        //   month:
        //     月（1 到 12）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   millisecond:
        //     毫秒（0 到 999）。
        //
        //   kind:
        //     列舉值之一，該值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地時間、協調世界時
        //     (UTC)，還是兩者皆未指定。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。 - 或 - month 小於 1 或大於 12。 - 或 - day 小於 1 或大於 month 中的天數。
        //     - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 - second 小於 0 或大於 59。
        //     - 或 - millisecond 小於 0 或大於 999。
        //
        //   System.ArgumentException:
        //     kind 不是 System.DateTimeKind 值之一。
        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind);
        //
        // 摘要:
        //     將 System.DateTime 結構的新例項初始化為指定日曆的指定年、月、日、小時、分鐘、秒、毫秒和協調世界時 (UTC) 或本地時間。
        //
        // 引數:
        //   year:
        //     年（1 到 calendar 中的年數）。
        //
        //   month:
        //     月（1 到 calendar 中的月數）。
        //
        //   day:
        //     日（1 到 month 中的天數）。
        //
        //   hour:
        //     小時（0 到 23）。
        //
        //   minute:
        //     分（0 到 59）。
        //
        //   second:
        //     秒（0 到 59）。
        //
        //   millisecond:
        //     毫秒（0 到 999）。
        //
        //   calendar:
        //     用於解釋 year、month 和 day 的日曆。
        //
        //   kind:
        //     列舉值之一，該值指示 year、month、day, hour、minute、second 和 millisecond 指定了本地時間、協調世界時
        //     (UTC)，還是兩者皆未指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     calendar 為 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     year 不在 calendar 所支援的範圍內。 - 或 - month 小於 1 或大於 calendar 中的月數。 - 或 - day 小於
        //     1 或大於 month 中的天數。 - 或 - hour 小於 0 或大於 23。 - 或 - minute 小於 0 或大於 59。 - 或 -
        //     second 小於 0 或大於 59。 - 或 - millisecond 小於 0 或大於 999。
        //
        //   System.ArgumentException:
        //     kind 不是 System.DateTimeKind 值之一。
        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind);

        // 摘要:
        //     將指定的日期和時間與另一個指定的日期和時間相減，返回一個時間間隔。
        //
        // 引數:
        //   d1:
        //     要從中減去的日期和時間值（被減數）。
        //
        //   d2:
        //     要減去的日期和時間值（減數）。
        //
        // 返回結果:
        //     d1 和 d2 之間的時間間隔；即 d1 減去 d2。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static TimeSpan operator -(DateTime d1, DateTime d2);
        //
        // 摘要:
        //     從指定的日期和時間減去指定的時間間隔，返回新的日期和時間。
        //
        // 引數:
        //   d:
        //     要從其中減去的日期和時間值。
        //
        //   t:
        //     待減去的時間間隔。
        //
        // 返回結果:
        //     一個物件，其值為 d 的值減去 t 的值。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public static DateTime operator -(DateTime d, TimeSpan t);
        //
        // 摘要:
        //     確定 System.DateTime 的兩個指定的例項是否不等。
        //
        // 引數:
        //   d1:
        //     要比較的第一個物件。
        //
        //   d2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 d1 和 d2 不表示同一日期和時間，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator !=(DateTime d1, DateTime d2);
        //
        // 摘要:
        //     將指定的時間間隔加到指定的日期和時間以生成新的日期和時間。
        //
        // 引數:
        //   d:
        //     要新增的日期和時間值。
        //
        //   t:
        //     待新增的時間間隔。
        //
        // 返回結果:
        //     一個物件，它是 d 和 t 值的和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public static DateTime operator +(DateTime d, TimeSpan t);
        //
        // 摘要:
        //     確定指定的 System.DateTime 是否小於另一個指定的 System.DateTime。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 t1 小於 t2，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator <(DateTime t1, DateTime t2);
        //
        // 摘要:
        //     確定指定的 System.DateTime 是否小於或等於另一個指定的 System.DateTime。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 t1 小於等於 t2，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator <=(DateTime t1, DateTime t2);
        //
        // 摘要:
        //     確定 System.DateTime 的兩個指定的例項是否相等。
        //
        // 引數:
        //   d1:
        //     要比較的第一個物件。
        //
        //   d2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 d1 和 d2 表示同一日期和時間，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator ==(DateTime d1, DateTime d2);
        //
        // 摘要:
        //     確定指定的 System.DateTime 是否大於另一個指定的 System.DateTime。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 t1 大於 t2，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator >(DateTime t1, DateTime t2);
        //
        // 摘要:
        //     確定指定的 System.DateTime 是否大於等於另一個指定的 System.DateTime。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果 t1 大於等於 t2，則為 true；否則為 false。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static bool operator >=(DateTime t1, DateTime t2);

        // 摘要:
        //     獲取此例項的日期部分。
        //
        // 返回結果:
        //     一個新物件，其日期與此例項相同，時間值設定為午夜 12:00:00 (00:00:00)。
        public DateTime Date { get; }
        //
        // 摘要:
        //     獲取此例項所表示的日期為該月中的第幾天。
        //
        // 返回結果:
        //     日組成部分，表示為 1 和 31 之間的一個值。
        public int Day { get; }
        //
        // 摘要:
        //     獲取此例項所表示的日期是星期幾。
        //
        // 返回結果:
        //     一個列舉常量，指示此 System.DateTime 值是星期幾。
        public DayOfWeek DayOfWeek { get; }
        //
        // 摘要:
        //     獲取此例項所表示的日期是該年中的第幾天。
        //
        // 返回結果:
        //     該年中的第幾天，表示為 1 和 366 之間的一個值。
        public int DayOfYear { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的小時部分。
        //
        // 返回結果:
        //     小時組成部分，表示為 0 和 23 之間的一個值。
        public int Hour { get; }
        //
        // 摘要:
        //     獲取一個值，該值指示由此例項表示的時間是基於本地時間、協調世界時 (UTC)，還是兩者皆否。
        //
        // 返回結果:
        //     用於指示當前時間表示的含義的列舉值之一。 預設值為 System.DateTimeKind.Unspecified。
        public DateTimeKind Kind { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的毫秒部分。
        //
        // 返回結果:
        //     毫秒組成部分，表示為 0 和 999 之間的一個值。
        public int Millisecond { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的分鐘部分。
        //
        // 返回結果:
        //     分鐘組成部分，表示為 0 和 59 之間的一個值。
        public int Minute { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的月份部分。
        //
        // 返回結果:
        //     月組成部分，表示為 1 和 12 之間的一個值。
        public int Month { get; }
        //
        // 摘要:
        //     獲取一個 System.DateTime 物件，該物件設定為此計算機上的當前日期和時間，表示為本地時間。
        //
        // 返回結果:
        //     其值為當前日期和時間的物件。
        public static DateTime Now { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的秒部分。
        //
        // 返回結果:
        //     秒組成部分，表示為 0 和 59 之間的一個值。
        public int Second { get; }
        //
        // 摘要:
        //     獲取表示此例項的日期和時間的計時週期數。
        //
        // 返回結果:
        //     表示此例項的日期和時間的計時週期數。 該值介於 DateTime.MinValue.Ticks 和 DateTime.MaxValue.Ticks
        //     之間。
        public long Ticks { get; }
        //
        // 摘要:
        //     獲取此例項的當天的時間。
        //
        // 返回結果:
        //     一個時間間隔，它表示當天自午夜以來已經過時間的部分。
        public TimeSpan TimeOfDay { get; }
        //
        // 摘要:
        //     獲取當前日期。
        //
        // 返回結果:
        //     一個物件，設定為當天日期，其時間組成部分設定為 00:00:00。
        public static DateTime Today { get; }
        //
        // 摘要:
        //     獲取一個 System.DateTime 物件，該物件設定為此計算機上的當前日期和時間，表示為協調通用時間 (UTC)。
        //
        // 返回結果:
        //     其值為當前 UTC 日期和時間的物件。
        public static DateTime UtcNow { get; }
        //
        // 摘要:
        //     獲取此例項所表示日期的年份部分。
        //
        // 返回結果:
        //     年份（介於 1 和 9999 之間）。
        public int Year { get; }

        // 摘要:
        //     返回一個新的 System.DateTime，它將指定 System.TimeSpan 的值加到此例項的值上。
        //
        // 引數:
        //   value:
        //     正或負時間間隔。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的時間間隔之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime Add(TimeSpan value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的天數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     由整數和小數部分組成的天數。 value 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的天數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddDays(double value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的小時數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     由整數和小數部分組成的小時數。 value 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的小時數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddHours(double value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的毫秒數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     由整數和小數部分組成的毫秒數。 value 引數可以是負數也可以是正數。 請注意，該值被舍入到最近的整數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的毫秒數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddMilliseconds(double value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的分鐘數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     由整數和小數部分組成的分鐘數。 value 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的分鐘數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddMinutes(double value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的月數加到此例項的值上。
        //
        // 引數:
        //   months:
        //     月份數。 months 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 months 所表示的時間之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        //     - 或 - months 小於 -120,000 或大於 120,000。
        public DateTime AddMonths(int months);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的秒數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     由整數和小數部分組成的秒數。 value 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的秒數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddSeconds(double value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的計時週期數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     以 100 納秒為單位的計時週期數。 value 引數可以是正數也可以是負數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的時間之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddTicks(long value);
        //
        // 摘要:
        //     返回一個新的 System.DateTime，它將指定的年份數加到此例項的值上。
        //
        // 引數:
        //   value:
        //     年份數。 value 引數可以是負數也可以是正數。
        //
        // 返回結果:
        //     一個物件，其值是此例項所表示的日期和時間與 value 所表示的年份數之和。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     value 或得到的 System.DateTime 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime AddYears(int value);
        //
        // 摘要:
        //     對兩個 System.DateTime 的例項進行比較，並返回一個指示第一個例項是早於、等於還是晚於第二個例項的整數。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     有符號數字，指示 t1 和 t2 的相對值。 值型別 Condition 小於零 t1 早於 t2。 零 t1 與 t2 相同。 大於零 t1 晚於
        //     t2。
        public static int Compare(DateTime t1, DateTime t2);
        //
        // 摘要:
        //     將此例項的值與指定的 System.DateTime 值相比較，並返回一個整數，該整數指示此例項是早於、等於還是晚於指定的 System.DateTime
        //     值。
        //
        // 引數:
        //   value:
        //     要與當前例項進行比較的物件。
        //
        // 返回結果:
        //     有符號數字，指示此例項和 value 引數的相對值。 值 說明 小於零 此例項早於 value。 零 此例項與 value 相同。 大於零 此例項晚於
        //     value。
        public int CompareTo(DateTime value);
        //
        // 摘要:
        //     將此例項的值與包含指定的 System.DateTime 值的指定物件相比較，並返回一個整數，該整數指示此例項是早於、等於還是晚於指定的 System.DateTime
        //     值。
        //
        // 引數:
        //   value:
        //     要比較的裝箱物件，或 null。
        //
        // 返回結果:
        //     一個有符號數字，指示此例項和 value 的相對值。 值 說明 小於零 此例項早於 value。 零 此例項與 value 相同。 大於零 此例項晚於
        //     value 或 value 為 null。
        //
        // 異常:
        //   System.ArgumentException:
        //     value 不是 System.DateTime。
        public int CompareTo(object value);
        //
        // 摘要:
        //     返回指定年和月中的天數。
        //
        // 引數:
        //   year:
        //     年。
        //
        //   month:
        //     月（介於 1 到 12 之間的一個數字）。
        //
        // 返回結果:
        //     指定 year 中 month 的天數。 例如，如果 month 等於 2（表示二月），則返回值為 28 或 29，具體取決於 year 是否為閏年。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     month 小於 1 或大於 12。 - 或 - year 小於 1 或大於 9999。
        public static int DaysInMonth(int year, int month);
        //
        // 摘要:
        //     返回一個值，該值指示此例項的值是否與指定的 System.DateTime 例項的值相等。
        //
        // 引數:
        //   value:
        //     要與此例項進行比較的物件。
        //
        // 返回結果:
        //     如果 value 引數等於此例項的值，則為 true；否則為 false。
        public bool Equals(DateTime value);
        //
        // 摘要:
        //     返回一個值，該值指示此例項是否等於指定的物件。
        //
        // 引數:
        //   value:
        //     要與此例項進行比較的物件。
        //
        // 返回結果:
        //     如果 value 是 System.DateTime 的例項並且等於此例項的值，則為 true；否則為 false。
        public override bool Equals(object value);
        //
        // 摘要:
        //     返回一個值，該值指示 System.DateTime 的兩個例項是否具有同一個日期和時間值。
        //
        // 引數:
        //   t1:
        //     要比較的第一個物件。
        //
        //   t2:
        //     要比較的第二個物件。
        //
        // 返回結果:
        //     如果兩個值相等，則為 true；否則為 false。
        public static bool Equals(DateTime t1, DateTime t2);
        //
        // 摘要:
        //     反序列化一個 64 位二進位制值，並重新建立序列化的 System.DateTime 初始物件。
        //
        // 引數:
        //   dateData:
        //     64 位帶符號整數，它對 2 位欄位的 System.DateTime.Kind 屬性以及 62 位欄位的 System.DateTime.Ticks
        //     屬性進行了編碼。
        //
        // 返回結果:
        //     一個物件，它等效於由 System.DateTime.ToBinary() 方法序列化的 System.DateTime 物件。
        //
        // 異常:
        //   System.ArgumentException:
        //     dateData 小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public static DateTime FromBinary(long dateData);
        //
        // 摘要:
        //     將指定的 Windows 檔案時間轉換為等效的本地時間。
        //
        // 引數:
        //   fileTime:
        //     以計時週期表示的 Windows 檔案時間。
        //
        // 返回結果:
        //     一個表示本地時間的物件，等效於由 fileTime 引數表示的日期和時間。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     fileTime 小於零或表示大於 System.DateTime.MaxValue 的時間。
        public static DateTime FromFileTime(long fileTime);
        //
        // 摘要:
        //     將指定的 Windows 檔案時間轉換為等效的 UTC 時間。
        //
        // 引數:
        //   fileTime:
        //     以計時週期表示的 Windows 檔案時間。
        //
        // 返回結果:
        //     一個表示 UTC 時間的物件，等效於由 fileTime 引數表示的日期和時間。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     fileTime 小於零或表示大於 System.DateTime.MaxValue 的時間。
        public static DateTime FromFileTimeUtc(long fileTime);
        //
        // 摘要:
        //     返回與指定的 OLE 自動化日期等效的 System.DateTime。
        //
        // 引數:
        //   d:
        //     OLE 自動化日期值。
        //
        // 返回結果:
        //     一個物件，它表示與 d 相同的日期和時間。
        //
        // 異常:
        //   System.ArgumentException:
        //     該日期不是有效的 OLE 自動化日期值。
        public static DateTime FromOADate(double d);
        //
        // 摘要:
        //     將此例項的值轉換為標準日期和時間格式說明符支援的所有字串表示形式。
        //
        // 返回結果:
        //     字串陣列，其中每個元素都表示此例項的以標準日期和時間格式說明符之一進行格式設定的一個值。
        public string[] GetDateTimeFormats();
        //
        // 摘要:
        //     將此例項的值轉換為指定的標準日期和時間格式說明符支援的所有字串表示形式。
        //
        // 引數:
        //   format:
        //     標準日期和時間格式字串（請參見注解）。
        //
        // 返回結果:
        //     字串陣列，其中每個元素都表示此例項的以 format 標準日期和時間格式說明符之一進行格式設定的一個值。
        //
        // 異常:
        //   System.FormatException:
        //     format 不是有效的標準日期和時間格式說明符。
        public string[] GetDateTimeFormats(char format);
        //
        // 摘要:
        //     將此例項的值轉換為標準日期和時間格式說明符和指定的區域性特定格式資訊支援的所有字串表示形式。
        //
        // 引數:
        //   provider:
        //     一個物件，它提供有關此例項的區域性特定格式設定資訊。
        //
        // 返回結果:
        //     字串陣列，其中每個元素都表示此例項的以標準日期和時間格式說明符之一進行格式設定的一個值。
        public string[] GetDateTimeFormats(IFormatProvider provider);
        //
        // 摘要:
        //     將此例項的值轉換為指定的標準日期和時間格式說明符和區域性特定格式資訊支援的所有字串表示形式。
        //
        // 引數:
        //   format:
        //     日期和時間格式的字串（請參見注解）。
        //
        //   provider:
        //     一個物件，它提供有關此例項的區域性特定格式設定資訊。
        //
        // 返回結果:
        //     字串陣列，其中每個元素都表示此例項的以標準日期和時間格式說明符之一進行格式設定的一個值。
        //
        // 異常:
        //   System.FormatException:
        //     format 不是有效的標準日期和時間格式說明符。
        public string[] GetDateTimeFormats(char format, IFormatProvider provider);
        //
        // 摘要:
        //     返回此例項的雜湊程式碼。
        //
        // 返回結果:
        //     32 位有符號整數雜湊程式碼。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public override int GetHashCode();
        //
        // 摘要:
        //     返回值型別 System.DateTime 的 System.TypeCode。
        //
        // 返回結果:
        //     列舉常數 System.TypeCode.DateTime。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public TypeCode GetTypeCode();
        //
        // 摘要:
        //     指示此 System.DateTime 例項是否在當前時區的夏時制範圍內。
        //
        // 返回結果:
        //     如果 System.DateTime.Kind 為 System.DateTimeKind.Local 或 System.DateTimeKind.Unspecified
        //     並且此 System.DateTime 例項的值在當前時區的夏時制範圍以內，則為 true。 如果 System.DateTime.Kind 為
        //     System.DateTimeKind.Utc，則返回 false。
        public bool IsDaylightSavingTime();
        //
        // 摘要:
        //     返回指定的年份是否為閏年的指示。
        //
        // 引數:
        //   year:
        //     四位數年份。
        //
        // 返回結果:
        //     如果 year 為閏年，則為 true；否則為 false。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     year 小於 1 或大於 9999。
        public static bool IsLeapYear(int year);
        //
        // 摘要:
        //     將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。
        //
        // 引數:
        //   s:
        //     包含要轉換的日期和時間的字串。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 為 null。
        //
        //   System.FormatException:
        //     s 中不包含有效的日期和時間的字串表示形式。
        public static DateTime Parse(string s);
        //
        // 摘要:
        //     使用指定的區域性特定格式資訊，將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。
        //
        // 引數:
        //   s:
        //     包含要轉換的日期和時間的字串。
        //
        //   provider:
        //     一個物件，提供有關 s 的區域性特定格式資訊。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間，由 provider 指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 為 null。
        //
        //   System.FormatException:
        //     s 中不包含有效的日期和時間的字串表示形式。
        public static DateTime Parse(string s, IFormatProvider provider);
        //
        // 摘要:
        //     使用指定的區域性特定格式資訊和格式設定樣式將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。
        //
        // 引數:
        //   s:
        //     包含要轉換的日期和時間的字串。
        //
        //   provider:
        //     一個物件，提供有關 s 的區域性特定格式設定資訊。
        //
        //   styles:
        //     列舉值的按位組合，用於指示 s 成功執行分析操作所需的樣式元素以及定義如何根據當前時區或當前日期解釋已分析日期的樣式元素。 一個用來指定的典型值為
        //     System.Globalization.DateTimeStyles.None。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間，由 provider 和 styles 指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 為 null。
        //
        //   System.FormatException:
        //     s 中不包含有效的日期和時間的字串表示形式。
        //
        //   System.ArgumentException:
        //     styles 包含 System.Globalization.DateTimeStyles 值的無效組合。 例如，System.Globalization.DateTimeStyles.AssumeLocal
        //     和 System.Globalization.DateTimeStyles.AssumeUniversal。
        public static DateTime Parse(string s, IFormatProvider provider, DateTimeStyles styles);
        //
        // 摘要:
        //     使用指定的格式和區域性特定格式資訊，將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。 字串表示形式的格式必須與指定的格式完全匹配。
        //
        // 引數:
        //   s:
        //     包含要轉換的日期和時間的字串。
        //
        //   format:
        //     用於定義所需的 s 格式的格式說明符。
        //
        //   provider:
        //     一個物件，提供有關 s 的區域性特定格式資訊。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間，由 format 和 provider 指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 或 format 為 null。
        //
        //   System.FormatException:
        //     s 或 format 是空字串。 - 或 - s 不包含與 format 中指定的模式相對應的日期和時間。 - 或 - s 中的小時組成部分和
        //     AM/PM 指示符不一致。
        public static DateTime ParseExact(string s, string format, IFormatProvider provider);
        //
        // 摘要:
        //     使用指定的格式、區域性特定的格式資訊和樣式將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。 字串表示形式的格式必須與指定的格式完全匹配，否則會引發異常。
        //
        // 引數:
        //   s:
        //     包含要轉換的日期和時間的字串。
        //
        //   format:
        //     用於定義所需的 s 格式的格式說明符。
        //
        //   provider:
        //     一個物件，提供有關 s 的區域性特定格式設定資訊。
        //
        //   style:
        //     列舉值的按位組合，提供有關以下內容的附加資訊：s、可能出現在 s 中的樣式元素或從 s 到 System.DateTime 值的轉換。 一個要指定的典型值為
        //     System.Globalization.DateTimeStyles.None。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間，由 format、provider 和 style 指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 或 format 為 null。
        //
        //   System.FormatException:
        //     s 或 format 是空字串。 - 或 - s 不包含與 format 中指定的模式相對應的日期和時間。 - 或 - s 中的小時組成部分和
        //     AM/PM 指示符不一致。
        //
        //   System.ArgumentException:
        //     style 包含無效的 System.Globalization.DateTimeStyles 值組合。 例如，System.Globalization.DateTimeStyles.AssumeLocal
        //     和 System.Globalization.DateTimeStyles.AssumeUniversal。
        public static DateTime ParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style);
        //
        // 摘要:
        //     使用指定的格式陣列、區域性特定格式資訊和樣式，將日期和時間的指定字串表示形式轉換為其等效的 System.DateTime。 字串表示形式的格式必須至少與指定的格式之一完全匹配，否則會引發異常。
        //
        // 引數:
        //   s:
        //     包含要轉換的一個或多個日期和時間的字串。
        //
        //   formats:
        //     s 的允許格式的陣列。
        //
        //   provider:
        //     一個物件，提供有關 s 的區域性特定格式資訊。
        //
        //   style:
        //     列舉值的一個按位組合，指示 s 所允許的格式。 一個要指定的典型值為 System.Globalization.DateTimeStyles.None。
        //
        // 返回結果:
        //     一個物件，它等效於 s 中包含的日期和時間，由 formats、provider 和 style 指定。
        //
        // 異常:
        //   System.ArgumentNullException:
        //     s 或 formats 為 null。
        //
        //   System.FormatException:
        //     s 是空字串。 - 或 - formats 的一個元素是空字串。 - 或 - s 不包含與 formats 中的任何元素對應的日期和時間。 -
        //     或 - s 中的小時組成部分和 AM/PM 指示符不一致。
        //
        //   System.ArgumentException:
        //     style 包含無效的 System.Globalization.DateTimeStyles 值組合。 例如，System.Globalization.DateTimeStyles.AssumeLocal
        //     和 System.Globalization.DateTimeStyles.AssumeUniversal。
        public static DateTime ParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style);
        //
        // 摘要:
        //     建立新的 System.DateTime 物件，該物件具有與指定的 System.DateTime 相同的刻度數，但是根據指定的 System.DateTimeKind
        //     值的指示，指定為本地時間或協調世界時 (UTC)，或者兩者皆否。
        //
        // 引數:
        //   value:
        //     日期和時間。
        //
        //   kind:
        //     列舉值之一，該值指示新物件是表示本地時間、UTC，還是兩者皆否。
        //
        // 返回結果:
        //     一個新物件，它具有與 value 引數表示的物件相同的刻度數以及由 kind 引數指定的 System.DateTimeKind 值。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static DateTime SpecifyKind(DateTime value, DateTimeKind kind);
        //
        // 摘要:
        //     從此例項中減去指定的日期和時間。
        //
        // 引數:
        //   value:
        //     要減去的日期和時間值。
        //
        // 返回結果:
        //     一個時間間隔，它等於此例項所表示的日期和時間減去 value 所表示的日期和時間。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     結果小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public TimeSpan Subtract(DateTime value);
        //
        // 摘要:
        //     從此例項中減去指定持續時間。
        //
        // 引數:
        //   value:
        //     待減去的時間間隔。
        //
        // 返回結果:
        //     一個物件，它等於此例項所表示的日期和時間減去 value 所表示的時間間隔。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     結果小於 System.DateTime.MinValue 或大於 System.DateTime.MaxValue。
        public DateTime Subtract(TimeSpan value);
        //
        // 摘要:
        //     將當前 System.DateTime 物件序列化為一個 64 位二進位制值，該值隨後可用於重新建立 System.DateTime 物件。
        //
        // 返回結果:
        //     64 位帶符號整數，它對 System.DateTime.Kind 和 System.DateTime.Ticks 屬性進行了編碼。
        public long ToBinary();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為 Windows 檔案時間。
        //
        // 返回結果:
        //     表示為 Windows 檔案時間的當前 System.DateTime 物件的值。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的檔案時間將表示協調世界時公元 1601 年 1 月 1 日午夜 12:00 之前的 日期和時間。
        public long ToFileTime();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為 Windows 檔案時間。
        //
        // 返回結果:
        //     表示為 Windows 檔案時間的當前 System.DateTime 物件的值。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     所生成的檔案時間將表示協調世界時公元 1601 年 1 月 1 日午夜 12:00 之前的 日期和時間。
        public long ToFileTimeUtc();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為本地時間。
        //
        // 返回結果:
        //     一個物件，其 System.DateTime.Kind 屬性為 System.DateTimeKind.Local，並且其值為等效於當前 System.DateTime
        //     物件的值的本地時間；如果經轉換的值過大以至於不能由 System.DateTime 物件表示，則為 System.DateTime.MaxValue，或者，如果經轉換的值過小以至於不能表示為
        //     System.DateTime 物件，則為 System.DateTime.MinValue。
        public DateTime ToLocalTime();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為其等效的長日期字串表示形式。
        //
        // 返回結果:
        //     一個字串，它包含當前 System.DateTime 物件的長日期字串表示形式。
        public string ToLongDateString();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為其等效的長時間字串表示形式。
        //
        // 返回結果:
        //     一個字串，它包含當前 System.DateTime 物件的長時間字串表示形式。
        public string ToLongTimeString();
        //
        // 摘要:
        //     將此例項的值轉換為等效的 OLE 自動化日期。
        //
        // 返回結果:
        //     一個雙精度浮點數，它包含與此例項的值等效的 OLE 自動化日期。
        //
        // 異常:
        //   System.OverflowException:
        //     此例項的值無法表示為 OLE 自動化日期。
        public double ToOADate();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為其等效的短日期字串表示形式。
        //
        // 返回結果:
        //     一個字串，它包含當前 System.DateTime 物件的短日期字串表示形式。
        public string ToShortDateString();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為其等效的短時間字串表示形式。
        //
        // 返回結果:
        //     一個字串，它包含當前 System.DateTime 物件的短時間字串表示形式。
        public string ToShortTimeString();
        //
        // 摘要:
        //     將當前 System.DateTime 物件的值轉換為其等效的字串表示形式。
        //
        // 返回結果:
        //     當前 System.DateTime 物件的值的字串表示形式。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     當前區域性所使用的日曆支援的日期範圍之外的日期和時間。
        public override string ToString();
        //
        // 摘要:
        //     使用指定的區域性特定格式資訊將當前 System.DateTime 物件的值轉換為它的等效字串表示形式。
        //
        // 引數:
        //   provider:
        //     一個提供區域性特定的格式設定資訊的物件。
        //
        // 返回結果:
        //     由 provider 指定的當前 System.DateTime 物件的值的字串表示形式。
        //
        // 異常:
        //   System.ArgumentOutOfRangeException:
        //     日期和時間處於由 provider 使用的日曆支援的日期範圍之外。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public string T