C#实现万年历(农历、节气、节日、星座、星宿、属相、生肖、闰年月、时辰)

gxm771208

C# 万年历 农历 节气 节日 星座 星宿 属相 生肖 闰年月 时辰
地址：http://www.cnblogs.com/txw1958/a ... sharp-calendar.html

1. 
   
2. using System.Collections.Generic;
   
3. using System.Text;
   
4. 
   
5. 
   
6. using System;
   
7. 
   
8. namespace yangliToyinli
   
9. {
   
10.     #region ChineseCalendarException
    
11.     /// <summary>
    
12.     /// 中国日历异常处理
    
13.     /// </summary>
    
14.     public class ChineseCalendarException : System.Exception
    
15.     {
    
16.         public ChineseCalendarException(string msg)
    
17.             : base(msg)
    
18.         {
    
19.         }
    
20.     }
    
21. 
    
22.     #endregion
    
23. 
    
24.     /// <summary>
    
25.     /// 中国农历类 版本V1.0 支持 1900.1.31日起至 2049.12.31日止的数据
    
26.     /// </summary>
    
27.     /// <remarks>
    
28.     /// 本程序使用数据来源于网上的万年历查询，并综合了一些其它数据
    
29.     /// </remarks>
    
30.     public class ChineseCalendar
    
31.     {
    
32.         #region 内部结构
    
33.         private struct SolarHolidayStruct
    
34.         {
    
35.             public int Month;
    
36.             public int Day;
    
37.             public int Recess; //假期长度
    
38.             public string HolidayName;
    
39.             public SolarHolidayStruct(int month, int day, int recess, string name)
    
40.             {
    
41.                 Month = month;
    
42.                 Day = day;
    
43.                 Recess = recess;
    
44.                 HolidayName = name;
    
45.             }
    
46.         }
    
47. 
    
48.         private struct LunarHolidayStruct
    
49.         {
    
50.             public int Month;
    
51.             public int Day;
    
52.             public int Recess;
    
53.             public string HolidayName;
    
54. 
    
55.             public LunarHolidayStruct(int month, int day, int recess, string name)
    
56.             {
    
57.                 Month = month;
    
58.                 Day = day;
    
59.                 Recess = recess;
    
60.                 HolidayName = name;
    
61.             }
    
62.         }
    
63. 
    
64.         private struct WeekHolidayStruct
    
65.         {
    
66.             public int Month;
    
67.             public int WeekAtMonth;
    
68.             public int WeekDay;
    
69.             public string HolidayName;
    
70. 
    
71.             public WeekHolidayStruct(int month, int weekAtMonth, int weekDay, string name)
    
72.             {
    
73.                 Month = month;
    
74.                 WeekAtMonth = weekAtMonth;
    
75.                 WeekDay = weekDay;
    
76.                 HolidayName = name;
    
77.             }
    
78.         }
    
79.         #endregion
    
80. 
    
81.         #region 内部变量
    
82.         private DateTime _date;
    
83.         private DateTime _datetime;
    
84. 
    
85.         private int _cYear;
    
86.         private int _cMonth;
    
87.         private int _cDay;
    
88.         private bool _cIsLeapMonth; //当月是否闰月
    
89.         private bool _cIsLeapYear; //当年是否有闰月
    
90.         #endregion
    
91. 
    
92.         #region 基础数据
    
93.         #region 基本常量
    
94.         private const int MinYear = 1900;
    
95.         private const int MaxYear = 2050;
    
96.         private static DateTime MinDay = new DateTime(1900, 1, 30);
    
97.         private static DateTime MaxDay = new DateTime(2049, 12, 31);
    
98.         private const int GanZhiStartYear = 1864; //干支计算起始年
    
99.         private static DateTime GanZhiStartDay = new DateTime(1899, 12, 22);//起始日
    
100.         private const string HZNum = "零一二三四五六七八九";
     
101.         private const int AnimalStartYear = 1900; //1900年为鼠年
     
102.         private static DateTime ChineseConstellationReferDay = new DateTime(2007, 9, 13);//28星宿参考值,本日为角
     
103.         #endregion
     
104. 
     
105.         #region 阴历数据
     
106.         /// <summary>
     
107.         /// 来源于网上的农历数据
     
108.         /// </summary>
     
109.         /// <remarks>
     
110.         /// 数据结构如下，共使用17位数据
     
111.         /// 第17位：表示闰月天数，0表示29天   1表示30天
     
112.         /// 第16位-第5位（共12位）表示12个月，其中第16位表示第一月，如果该月为30天则为1，29天为0
     
113.         /// 第4位-第1位（共4位）表示闰月是哪个月，如果当年没有闰月，则置0
     
114.         ///</remarks>
     
115.         private static int[] LunarDateArray = new int[]{
     
116.                 0x04BD8,0x04AE0,0x0A570,0x054D5,0x0D260,0x0D950,0x16554,0x056A0,0x09AD0,0x055D2,
     
117.                 0x04AE0,0x0A5B6,0x0A4D0,0x0D250,0x1D255,0x0B540,0x0D6A0,0x0ADA2,0x095B0,0x14977,
     
118.                 0x04970,0x0A4B0,0x0B4B5,0x06A50,0x06D40,0x1AB54,0x02B60,0x09570,0x052F2,0x04970,
     
119.                 0x06566,0x0D4A0,0x0EA50,0x06E95,0x05AD0,0x02B60,0x186E3,0x092E0,0x1C8D7,0x0C950,
     
120.                 0x0D4A0,0x1D8A6,0x0B550,0x056A0,0x1A5B4,0x025D0,0x092D0,0x0D2B2,0x0A950,0x0B557,
     
121.                 0x06CA0,0x0B550,0x15355,0x04DA0,0x0A5B0,0x14573,0x052B0,0x0A9A8,0x0E950,0x06AA0,
     
122.                 0x0AEA6,0x0AB50,0x04B60,0x0AAE4,0x0A570,0x05260,0x0F263,0x0D950,0x05B57,0x056A0,
     
123.                 0x096D0,0x04DD5,0x04AD0,0x0A4D0,0x0D4D4,0x0D250,0x0D558,0x0B540,0x0B6A0,0x195A6,
     
124.                 0x095B0,0x049B0,0x0A974,0x0A4B0,0x0B27A,0x06A50,0x06D40,0x0AF46,0x0AB60,0x09570,
     
125.                 0x04AF5,0x04970,0x064B0,0x074A3,0x0EA50,0x06B58,0x055C0,0x0AB60,0x096D5,0x092E0,
     
126.                 0x0C960,0x0D954,0x0D4A0,0x0DA50,0x07552,0x056A0,0x0ABB7,0x025D0,0x092D0,0x0CAB5,
     
127.                 0x0A950,0x0B4A0,0x0BAA4,0x0AD50,0x055D9,0x04BA0,0x0A5B0,0x15176,0x052B0,0x0A930,
     
128.                 0x07954,0x06AA0,0x0AD50,0x05B52,0x04B60,0x0A6E6,0x0A4E0,0x0D260,0x0EA65,0x0D530,
     
129.                 0x05AA0,0x076A3,0x096D0,0x04BD7,0x04AD0,0x0A4D0,0x1D0B6,0x0D250,0x0D520,0x0DD45,
     
130.                 0x0B5A0,0x056D0,0x055B2,0x049B0,0x0A577,0x0A4B0,0x0AA50,0x1B255,0x06D20,0x0ADA0,
     
131.                 0x14B63        
     
132.                 };
     
133. 
     
134.         #endregion
     
135. 
     
136.         #region 星座名称
     
137.         private static string[] _constellationName =
     
138.                 {
     
139.                     "白羊座", "金牛座", "双子座",
     
140.                     "巨蟹座", "狮子座", "处女座",
     
141.                     "天秤座", "天蝎座", "射手座",
     
142.                     "摩羯座", "水瓶座", "双鱼座"
     
143.                 };
     
144.         #endregion
     
145. 
     
146.         #region 二十四节气
     
147.         private static string[] _lunarHolidayName =
     
148.                     {
     
149.                     "小寒", "大寒", "立春", "雨水",
     
150.                     "惊蛰", "春分", "清明", "谷雨",
     
151.                     "立夏", "小满", "芒种", "夏至",
     
152.                     "小暑", "大暑", "立秋", "处暑",
     
153.                     "白露", "秋分", "寒露", "霜降",
     
154.                     "立冬", "小雪", "大雪", "冬至"
     
155.                     };
     
156.         #endregion
     
157. 
     
158.         #region 二十八星宿
     
159.         private static string[] _chineseConstellationName =
     
160.             {
     
161.                   //四        五      六         日        一      二      三  
     
162.                 "角木蛟","亢金龙","女土蝠","房日兔","心月狐","尾火虎","箕水豹",
     
163.                 "斗木獬","牛金牛","氐土貉","虚日鼠","危月燕","室火猪","壁水獝",
     
164.                 "奎木狼","娄金狗","胃土彘","昴日鸡","毕月乌","觜火猴","参水猿",
     
165.                 "井木犴","鬼金羊","柳土獐","星日马","张月鹿","翼火蛇","轸水蚓"
     
166.             };
     
167.         #endregion
     
168. 
     
169.         #region 节气数据
     
170.         private static string[] SolarTerm = new string[] { "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", "小满", "芒种", "夏至", "小暑", "大暑", "立秋", "处暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪", "冬至" };
     
171.         private static int[] sTermInfo = new int[] { 0, 21208, 42467, 63836, 85337, 107014, 128867, 150921, 173149, 195551, 218072, 240693, 263343, 285989, 308563, 331033, 353350, 375494, 397447, 419210, 440795, 462224, 483532, 504758 };
     
172.         #endregion
     
173. 
     
174.         #region 农历相关数据
     
175.         private static string ganStr = "甲乙丙丁戊己庚辛壬癸";
     
176.         private static string zhiStr = "子丑寅卯辰巳午未申酉戌亥";
     
177.         private static string animalStr = "鼠牛虎兔龙蛇马羊猴鸡狗猪";
     
178.         private static string nStr1 = "日一二三四五六七八九";
     
179.         private static string nStr2 = "初十廿卅";
     
180.         private static string[] _monthString =
     
181.                 {
     
182.                     "出错","正月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","腊月"
     
183.                 };
     
184.         #endregion
     
185. 
     
186.         #region 按公历计算的节日
     
187.         private static SolarHolidayStruct[] sHolidayInfo = new SolarHolidayStruct[]{
     
188.             new SolarHolidayStruct(1, 1, 1, "元旦"),
     
189.             new SolarHolidayStruct(2, 2, 0, "世界湿地日"),
     
190.             new SolarHolidayStruct(2, 10, 0, "国际气象节"),
     
191.             new SolarHolidayStruct(2, 14, 0, "情人节"),
     
192.             new SolarHolidayStruct(3, 1, 0, "国际海豹日"),
     
193.             new SolarHolidayStruct(3, 5, 0, "学雷锋纪念日"),
     
194.             new SolarHolidayStruct(3, 8, 0, "妇女节"),
     
195.             new SolarHolidayStruct(3, 12, 0, "植树节 孙中山逝世纪念日"),
     
196.             new SolarHolidayStruct(3, 14, 0, "国际警察日"),
     
197.             new SolarHolidayStruct(3, 15, 0, "消费者权益日"),
     
198.             new SolarHolidayStruct(3, 17, 0, "中国国医节 国际航海日"),
     
199.             new SolarHolidayStruct(3, 21, 0, "世界森林日 消除种族歧视国际日 世界儿歌日"),
     
200.             new SolarHolidayStruct(3, 22, 0, "世界水日"),
     
201.             new SolarHolidayStruct(3, 24, 0, "世界防治结核病日"),
     
202.             new SolarHolidayStruct(4, 1, 0, "愚人节"),
     
203.             new SolarHolidayStruct(4, 7, 0, "世界卫生日"),
     
204.             new SolarHolidayStruct(4, 22, 0, "世界地球日"),
     
205.             new SolarHolidayStruct(5, 1, 1, "劳动节"),
     
206.             new SolarHolidayStruct(5, 2, 1, "劳动节假日"),
     
207.             new SolarHolidayStruct(5, 3, 1, "劳动节假日"),
     
208.             new SolarHolidayStruct(5, 4, 0, "青年节"),
     
209.             new SolarHolidayStruct(5, 8, 0, "世界红十字日"),
     
210.             new SolarHolidayStruct(5, 12, 0, "国际护士节"),
     
211.             new SolarHolidayStruct(5, 31, 0, "世界无烟日"),
     
212.             new SolarHolidayStruct(6, 1, 0, "国际儿童节"),
     
213.             new SolarHolidayStruct(6, 5, 0, "世界环境保护日"),
     
214.             new SolarHolidayStruct(6, 26, 0, "国际禁毒日"),
     
215.             new SolarHolidayStruct(7, 1, 0, "建党节 香港回归纪念 世界建筑日"),
     
216.             new SolarHolidayStruct(7, 11, 0, "世界人口日"),
     
217.             new SolarHolidayStruct(8, 1, 0, "建军节"),
     
218.             new SolarHolidayStruct(8, 8, 0, "中国男子节 父亲节"),
     
219.             new SolarHolidayStruct(8, 15, 0, "抗日战争胜利纪念"),
     
220.             new SolarHolidayStruct(9, 9, 0, "  逝世纪念"),
     
221.             new SolarHolidayStruct(9, 10, 0, "教师节"),
     
222.             new SolarHolidayStruct(9, 18, 0, "九·一八事变纪念日"),
     
223.             new SolarHolidayStruct(9, 20, 0, "国际爱牙日"),
     
224.             new SolarHolidayStruct(9, 27, 0, "世界旅游日"),
     
225.             new SolarHolidayStruct(9, 28, 0, "孔子诞辰"),
     
226.             new SolarHolidayStruct(10, 1, 1, "国庆节 国际音乐日"),
     
227.             new SolarHolidayStruct(10, 2, 1, "国庆节假日"),
     
228.             new SolarHolidayStruct(10, 3, 1, "国庆节假日"),
     
229.             new SolarHolidayStruct(10, 6, 0, "老人节"),
     
230.             new SolarHolidayStruct(10, 24, 0, "联合国日"),
     
231.             new SolarHolidayStruct(11, 10, 0, "世界青年节"),
     
232.             new SolarHolidayStruct(11, 12, 0, "孙中山诞辰纪念"),
     
233.             new SolarHolidayStruct(12, 1, 0, "世界艾滋病日"),
     
234.             new SolarHolidayStruct(12, 3, 0, "世界残疾人日"),
     
235.             new SolarHolidayStruct(12, 20, 0, "澳门回归纪念"),
     
236.             new SolarHolidayStruct(12, 24, 0, "平安夜"),
     
237.             new SolarHolidayStruct(12, 25, 0, "圣诞节"),
     
238.             new SolarHolidayStruct(12, 26, 0, " 诞辰纪念")
     
239.            };
     
240.         #endregion
     
241. 
     
242.         #region 按农历计算的节日
     
243.         private static LunarHolidayStruct[] lHolidayInfo = new LunarHolidayStruct[]{
     
244.             new LunarHolidayStruct(1, 1, 1, "春节"),
     
245.             new LunarHolidayStruct(1, 15, 0, "元宵节"),
     
246.             new LunarHolidayStruct(5, 5, 0, "端午节"),
     
247.             new LunarHolidayStruct(7, 7, 0, "七夕情人节"),
     
248.             new LunarHolidayStruct(7, 15, 0, "中元节 盂兰盆节"),
     
249.             new LunarHolidayStruct(8, 15, 0, "中秋节"),
     
250.             new LunarHolidayStruct(9, 9, 0, "重阳节"),
     
251.             new LunarHolidayStruct(12, 8, 0, "腊八节"),
     
252.             new LunarHolidayStruct(12, 23, 0, "北方小年(扫房)"),
     
253.             new LunarHolidayStruct(12, 24, 0, "南方小年(掸尘)"),
     
254.             //new LunarHolidayStruct(12, 30, 0, "除夕")  //注意除夕需要其它方法进行计算
     
255.         };
     
256.         #endregion
     
257. 
     
258.         #region 按某月第几个星期几
     
259.         private static WeekHolidayStruct[] wHolidayInfo = new WeekHolidayStruct[]{
     
260.             new WeekHolidayStruct(5, 2, 1, "母亲节"),
     
261.             new WeekHolidayStruct(5, 3, 1, "全国助残日"),
     
262.             new WeekHolidayStruct(6, 3, 1, "父亲节"),
     
263.             new WeekHolidayStruct(9, 3, 3, "国际和平日"),
     
264.             new WeekHolidayStruct(9, 4, 1, "国际聋人节"),
     
265.             new WeekHolidayStruct(10, 1, 2, "国际住房日"),
     
266.             new WeekHolidayStruct(10, 1, 4, "国际减轻自然灾害日"),
     
267.             new WeekHolidayStruct(11, 4, 5, "感恩节")
     
268.         };
     
269.         #endregion
     
270. 
     
271.         #endregion
     
272. 
     
273.         #region 构造函数
     
274.         #region ChinaCalendar <公历日期初始化>
     
275.         /// <summary>
     
276.         /// 用一个标准的公历日期来初使化
     
277.         /// </summary>
     
278.         /// <param name="dt"></param>
     
279.         public ChineseCalendar(DateTime dt)
     
280.         {
     
281.             int i;
     
282.             int leap;
     
283.             int temp;
     
284.             int offset;
     
285. 
     
286.             CheckDateLimit(dt);
     
287. 
     
288.             _date = dt.Date;
     
289.             _datetime = dt;
     
290. 
     
291.             //农历日期计算部分
     
292.             leap = 0;
     
293.             temp = 0;
     
294. 
     
295.             TimeSpan ts = _date - ChineseCalendar.MinDay;//计算两天的基本差距
     
296.             offset = ts.Days;
     
297. 
     
298.             for (i = MinYear; i <= MaxYear; i++)
     
299.             {
     
300.                 temp = GetChineseYearDays(i);  //求当年农历年天数
     
301.                 if (offset - temp < 1)
     
302.                     break;
     
303.                 else
     
304.                 {
     
305.                     offset = offset - temp;
     
306.                 }
     
307.             }
     
308.             _cYear = i;
     
309. 
     
310.             leap = GetChineseLeapMonth(_cYear);//计算该年闰哪个月
     
311.             //设定当年是否有闰月
     
312.             if (leap > 0)
     
313.             {
     
314.                 _cIsLeapYear = true;
     
315.             }
     
316.             else
     
317.             {
     
318.                 _cIsLeapYear = false;
     
319.             }
     
320. 
     
321.             _cIsLeapMonth = false;
     
322.             for (i = 1; i <= 12; i++)
     
323.             {
     
324.                 //闰月
     
325.                 if ((leap > 0) && (i == leap + 1) && (_cIsLeapMonth == false))
     
326.                 {
     
327.                     _cIsLeapMonth = true;
     
328.                     i = i - 1;
     
329.                     temp = GetChineseLeapMonthDays(_cYear); //计算闰月天数
     
330.                 }
     
331.                 else
     
332.                 {
     
333.                     _cIsLeapMonth = false;
     
334.                     temp = GetChineseMonthDays(_cYear, i);//计算非闰月天数
     
335.                 }
     
336. 
     
337.                 offset = offset - temp;
     
338.                 if (offset <= 0) break;
     
339.             }
     
340. 
     
341.             offset = offset + temp;
     
342.             _cMonth = i;
     
343.             _cDay = offset;
     
344.         }
     
345.         #endregion
     
346. 
     
347.         #region ChinaCalendar <农历日期初始化>
     
348.         /// <summary>
     
349.         /// 用农历的日期来初使化
     
350.         /// </summary>
     
351.         /// <param name="cy">农历年</param>
     
352.         /// <param name="cm">农历月</param>
     
353.         /// <param name="cd">农历日</param>
     
354.         /// <param name="LeapFlag">闰月标志</param>
     
355.         public ChineseCalendar(int cy, int cm, int cd, bool leapMonthFlag)
     
356.         {
     
357.             int i, leap, Temp, offset;
     
358. 
     
359.             CheckChineseDateLimit(cy, cm, cd, leapMonthFlag);
     
360. 
     
361.             _cYear = cy;
     
362.             _cMonth = cm;
     
363.             _cDay = cd;
     
364. 
     
365.             offset = 0;
     
366. 
     
367.             for (i = MinYear; i < cy; i++)
     
368.             {
     
369.                 Temp = GetChineseYearDays(i); //求当年农历年天数
     
370.                 offset = offset + Temp;
     
371.             }
     
372. 
     
373.             leap = GetChineseLeapMonth(cy);// 计算该年应该闰哪个月
     
374.             if (leap != 0)
     
375.             {
     
376.                 this._cIsLeapYear = true;
     
377.             }
     
378.             else
     
379.             {
     
380.                 this._cIsLeapYear = false;
     
381.             }
     
382. 
     
383.             if (cm != leap)
     
384.             {
     
385.                 _cIsLeapMonth = false;  //当前日期并非闰月
     
386.             }
     
387.             else
     
388.             {
     
389.                 _cIsLeapMonth = leapMonthFlag;  //使用用户输入的是否闰月月份
     
390.             }
     
391. 
     
392. 
     
393.             if ((_cIsLeapYear == false) || //当年没有闰月
     
394.                  (cm < leap)) //计算月份小于闰月     
     
395.             {
     
396.                 #region ...
     
397.                 for (i = 1; i < cm; i++)
     
398.                 {
     
399.                     Temp = GetChineseMonthDays(cy, i);//计算非闰月天数
     
400.                     offset = offset + Temp;
     
401.                 }
     
402. 
     
403.                 //检查日期是否大于最大天
     
404.                 if (cd > GetChineseMonthDays(cy, cm))
     
405.                 {
     
406.                     throw new ChineseCalendarException("不合法的农历日期");
     
407.                 }
     
408.                 offset = offset + cd; //加上当月的天数
     
409.                 #endregion
     
410.             }
     
411.             else   //是闰年，且计算月份大于或等于闰月
     
412.             {
     
413.                 #region ...
     
414.                 for (i = 1; i < cm; i++)
     
415.                 {
     
416.                     Temp = GetChineseMonthDays(cy, i); //计算非闰月天数
     
417.                     offset = offset + Temp;
     
418.                 }
     
419. 
     
420.                 if (cm > leap) //计算月大于闰月
     
421.                 {
     
422.                     Temp = GetChineseLeapMonthDays(cy);   //计算闰月天数
     
423.                     offset = offset + Temp;               //加上闰月天数
     
424. 
     
425.                     if (cd > GetChineseMonthDays(cy, cm))
     
426.                     {
     
427.                         throw new ChineseCalendarException("不合法的农历日期");
     
428.                     }
     
429.                     offset = offset + cd;
     
430.                 }
     
431.                 else  //计算月等于闰月
     
432.                 {
     
433.                     //如果需要计算的是闰月，则应首先加上与闰月对应的普通月的天数
     
434.                     if (this._cIsLeapMonth == true) //计算月为闰月
     
435.                     {
     
436.                         Temp = GetChineseMonthDays(cy, cm); //计算非闰月天数
     
437.                         offset = offset + Temp;
     
438.                     }
     
439. 
     
440.                     if (cd > GetChineseLeapMonthDays(cy))
     
441.                     {
     
442.                         throw new ChineseCalendarException("不合法的农历日期");
     
443.                     }
     
444.                     offset = offset + cd;
     
445.                 }
     
446.                 #endregion
     
447.             }
     
448. 
     
449. 
     
450.             _date = MinDay.AddDays(offset);
     
451.         }
     
452.         #endregion
     
453.         #endregion
     
454. 
     
455.         #region 私有函数
     
456. 
     
457.         #region GetChineseMonthDays
     
458.         //传回农历 y年m月的总天数
     
459.         private int GetChineseMonthDays(int year, int month)
     
460.         {
     
461.             if (BitTest32((LunarDateArray[year - MinYear] & 0x0000FFFF), (16 - month)))
     
462.             {
     
463.                 return 30;
     
464.             }
     
465.             else
     
466.             {
     
467.                 return 29;
     
468.             }
     
469.         }
     
470.         #endregion
     
471. 
     
472.         #region GetChineseLeapMonth
     
473.         //传回农历 y年闰哪个月 1-12 , 没闰传回 0
     
474.         private int GetChineseLeapMonth(int year)
     
475.         {
     
476. 
     
477.             return LunarDateArray[year - MinYear] & 0xF;
     
478. 
     
479.         }
     
480.         #endregion
     
481. 
     
482.         #region GetChineseLeapMonthDays
     
483.         //传回农历 y年闰月的天数
     
484.         private int GetChineseLeapMonthDays(int year)
     
485.         {
     
486.             if (GetChineseLeapMonth(year) != 0)
     
487.             {
     
488.                 if ((LunarDateArray[year - MinYear] & 0x10000) != 0)
     
489.                 {
     
490.                     return 30;
     
491.                 }
     
492.                 else
     
493.                 {
     
494.                     return 29;
     
495.                 }
     
496.             }
     
497.             else
     
498.             {
     
499.                 return 0;
     
500.             }
     
501.         }
     
502.         #endregion
     
503. 
     
504.         #region GetChineseYearDays
     
505.         /// <summary>
     
506.         /// 取农历年一年的天数
     
507.         /// </summary>
     
508.         /// <param name="year"></param>
     
509.         /// <returns></returns>
     
510.         private int GetChineseYearDays(int year)
     
511.         {
     
512.             int i, f, sumDay, info;
     
513. 
     
514.             sumDay = 348; //29天 X 12个月
     
515.             i = 0x8000;
     
516.             info = LunarDateArray[year - MinYear] & 0x0FFFF;
     
517. 
     
518.             //计算12个月中有多少天为30天
     
519.             for (int m = 0; m < 12; m++)
     
520.             {
     
521.                 f = info & i;
     
522.                 if (f != 0)
     
523.                 {
     
524.                     sumDay++;
     
525.                 }
     
526.                 i = i >> 1;
     
527.             }
     
528.             return sumDay + GetChineseLeapMonthDays(year);
     
529.         }
     
530.         #endregion
     
531. 
     
532.         #region GetChineseHour
     
533.         /// <summary>
     
534.         /// 获得当前时间的时辰
     
535.         /// </summary>
     
536.         /// <param name="time"></param>
     
537.         /// <returns></returns>
     
538.         ///
     
539.         private string GetChineseHour(DateTime dt)
     
540.         {
     
541. 
     
542.             int _hour, _minute, offset, i;
     
543.             int indexGan;
     
544.             string ganHour, zhiHour;
     
545.             string tmpGan;
     
546. 
     
547.             //计算时辰的地支
     
548.             _hour = dt.Hour;    //获得当前时间小时
     
549.             _minute = dt.Minute;  //获得当前时间分钟
     
550. 
     
551.             if (_minute != 0) _hour += 1;
     
552.             offset = _hour / 2;
     
553.             if (offset >= 12) offset = 0;
     
554.             //zhiHour = zhiStr[offset].ToString();
     
555. 
     
556.             //计算天干
     
557.             TimeSpan ts = this._date - GanZhiStartDay;
     
558.             i = ts.Days % 60;
     
559. 
     
560.             indexGan = ((i % 10 + 1) * 2 - 1) % 10 - 1; //ganStr[i % 10] 为日的天干,(n*2-1) %10得出地支对应,n从1开始
     
561.             tmpGan = ganStr.Substring(indexGan) + ganStr.Substring(0, indexGan + 2);//凑齐12位
     
562.             //ganHour = ganStr[((i % 10 + 1) * 2 - 1) % 10 - 1].ToString();
     
563. 
     
564.             return tmpGan[offset].ToString() + zhiStr[offset].ToString();
     
565. 
     
566.         }
     
567.         #endregion
     
568. 
     
569.         #region CheckDateLimit
     
570.         /// <summary>
     
571.         /// 检查公历日期是否符合要求
     
572.         /// </summary>
     
573.         /// <param name="dt"></param>
     
574.         private void CheckDateLimit(DateTime dt)
     
575.         {
     
576.             if ((dt < MinDay) || (dt > MaxDay))
     
577.             {
     
578.                 throw new ChineseCalendarException("超出可转换的日期");
     
579.             }
     
580.         }
     
581.         #endregion
     
582. 
     
583.         #region CheckChineseDateLimit
     
584.         /// <summary>
     
585.         /// 检查农历日期是否合理
     
586.         /// </summary>
     
587.         /// <param name="year"></param>
     
588.         /// <param name="month"></param>
     
589.         /// <param name="day"></param>
     
590.         /// <param name="leapMonth"></param>
     
591.         private void CheckChineseDateLimit(int year, int month, int day, bool leapMonth)
     
592.         {
     
593.             if ((year < MinYear) || (year > MaxYear))
     
594.             {
     
595.                 throw new ChineseCalendarException("非法农历日期");
     
596.             }
     
597.             if ((month < 1) || (month > 12))
     
598.             {
     
599.                 throw new ChineseCalendarException("非法农历日期");
     
600.             }
     
601.             if ((day < 1) || (day > 30)) //中国的月最多30天
     
602.             {
     
603.                 throw new ChineseCalendarException("非法农历日期");
     
604.             }
     
605. 
     
606.             int leap = GetChineseLeapMonth(year);// 计算该年应该闰哪个月
     
607.             if ((leapMonth == true) && (month != leap))
     
608.             {
     
609.                 throw new ChineseCalendarException("非法农历日期");
     
610.             }
     
611. 
     
612. 
     
613.         }
     
614.         #endregion
     
615. 
     
616.         #region ConvertNumToChineseNum
     
617.         /// <summary>
     
618.         /// 将0-9转成汉字形式
     
619.         /// </summary>
     
620.         /// <param name="n"></param>
     
621.         /// <returns></returns>
     
622.         private string ConvertNumToChineseNum(char n)
     
623.         {
     
624.             if ((n < '0') || (n > '9')) return "";
     
625.             switch (n)
     
626.             {
     
627.                 case '0':
     
628.                     return HZNum[0].ToString();
     
629.                 case '1':
     
630.                     return HZNum[1].ToString();
     
631.                 case '2':
     
632.                     return HZNum[2].ToString();
     
633.                 case '3':
     
634.                     return HZNum[3].ToString();
     
635.                 case '4':
     
636.                     return HZNum[4].ToString();
     
637.                 case '5':
     
638.                     return HZNum[5].ToString();
     
639.                 case '6':
     
640.                     return HZNum[6].ToString();
     
641.                 case '7':
     
642.                     return HZNum[7].ToString();
     
643.                 case '8':
     
644.                     return HZNum[8].ToString();
     
645.                 case '9':
     
646.                     return HZNum[9].ToString();
     
647.                 default:
     
648.                     return "";
     
649.             }
     
650.         }
     
651.         #endregion
     
652. 
     
653.         #region BitTest32
     
654.         /// <summary>
     
655.         /// 测试某位是否为真
     
656.         /// </summary>
     
657.         /// <param name="num"></param>
     
658.         /// <param name="bitpostion"></param>
     
659.         /// <returns></returns>
     
660.         private bool BitTest32(int num, int bitpostion)
     
661.         {
     
662. 
     
663.             if ((bitpostion > 31) || (bitpostion < 0))
     
664.                 throw new Exception("Error Param: bitpostion[0-31]:" + bitpostion.ToString());
     
665. 
     
666.             int bit = 1 << bitpostion;
     
667. 
     
668.             if ((num & bit) == 0)
     
669.             {
     
670.                 return false;
     
671.             }
     
672.             else
     
673.             {
     
674.                 return true;
     
675.             }
     
676.         }
     
677.         #endregion
     
678. 
     
679.         #region ConvertDayOfWeek
     
680.         /// <summary>
     
681.         /// 将星期几转成数字表示
     
682.         /// </summary>
     
683.         /// <param name="dayOfWeek"></param>
     
684.         /// <returns></returns>
     
685.         private int ConvertDayOfWeek(DayOfWeek dayOfWeek)
     
686.         {
     
687.             switch (dayOfWeek)
     
688.             {
     
689.                 case DayOfWeek.Sunday:
     
690.                     return 1;
     
691.                 case DayOfWeek.Monday:
     
692.                     return 2;
     
693.                 case DayOfWeek.Tuesday:
     
694.                     return 3;
     
695.                 case DayOfWeek.Wednesday:
     
696.                     return 4;
     
697.                 case DayOfWeek.Thursday:
     
698.                     return 5;
     
699.                 case DayOfWeek.Friday:
     
700.                     return 6;
     
701.                 case DayOfWeek.Saturday:
     
702.                     return 7;
     
703.                 default:
     
704.                     return 0;
     
705.             }
     
706.         }
     
707.         #endregion
     
708. 
     
709.         #region CompareWeekDayHoliday
     
710.         /// <summary>
     
711.         /// 比较当天是不是指定的第周几
     
712.         /// </summary>
     
713.         /// <param name="date"></param>
     
714.         /// <param name="month"></param>
     
715.         /// <param name="week"></param>
     
716.         /// <param name="day"></param>
     
717.         /// <returns></returns>
     
718.         private bool CompareWeekDayHoliday(DateTime date, int month, int week, int day)
     
719.         {
     
720.             bool ret = false;
     
721. 
     
722.             if (date.Month == month) //月份相同
     
723.             {
     
724.                 if (ConvertDayOfWeek(date.DayOfWeek) == day) //星期几相同
     
725.                 {
     
726.                     DateTime firstDay = new DateTime(date.Year, date.Month, 1);//生成当月第一天
     
727.                     int i = ConvertDayOfWeek(firstDay.DayOfWeek);
     
728.                     int firWeekDays = 7 - ConvertDayOfWeek(firstDay.DayOfWeek) + 1; //计算第一周剩余天数
     
729. 
     
730.                     if (i > day)
     
731.                     {
     
732.                         if ((week - 1) * 7 + day + firWeekDays == date.Day)
     
733.                         {
     
734.                             ret = true;
     
735.                         }
     
736.                     }
     
737.                     else
     
738.                     {
     
739.                         if (day + firWeekDays + (week - 2) * 7 == date.Day)
     
740.                         {
     
741.                             ret = true;
     
742.                         }
     
743.                     }
     
744.                 }
     
745.             }
     
746. 
     
747.             return ret;
     
748.         }
     
749.         #endregion
     
750.         #endregion
     
751. 
     
752.         #region  属性
     
753. 
     
754.         #region 节日
     
755.         #region ChineseCalendarHoliday
     
756.         /// <summary>
     
757.         /// 计算中国农历节日
     
758.         /// </summary>
     
759.         public string ChineseCalendarHoliday
     
760.         {
     
761.             get
     
762.             {
     
763.                 string tempStr = "";
     
764.                 if (this._cIsLeapMonth == false) //闰月不计算节日
     
765.                 {
     
766.                     foreach (LunarHolidayStruct lh in lHolidayInfo)
     
767.                     {
     
768.                         if ((lh.Month == this._cMonth) && (lh.Day == this._cDay))
     
769.                         {
     
770. 
     
771.                             tempStr = lh.HolidayName;
     
772.                             break;
     
773. 
     
774.                         }
     
775.                     }
     
776. 
     
777.                     //对除夕进行特别处理
     
778.                     if (this._cMonth == 12)
     
779.                     {
     
780.                         int i = GetChineseMonthDays(this._cYear, 12); //计算当年农历12月的总天数
     
781.                         if (this._cDay == i) //如果为最后一天
     
782.                         {
     
783.                             tempStr = "除夕";
     
784.                         }
     
785.                     }
     
786.                 }
     
787.                 return tempStr;
     
788.             }
     
789.         }
     
790.         #endregion
     
791. 
     
792.         #region WeekDayHoliday
     
793.         /// <summary>
     
794.         /// 按某月第几周第几日计算的节日
     
795.         /// </summary>
     
796.         public string WeekDayHoliday
     
797.         {
     
798.             get
     
799.             {
     
800.                 string tempStr = "";
     
801.                 foreach (WeekHolidayStruct wh in wHolidayInfo)
     
802.                 {
     
803.                     if (CompareWeekDayHoliday(_date, wh.Month, wh.WeekAtMonth, wh.WeekDay))
     
804.                     {
     
805.                         tempStr = wh.HolidayName;
     
806.                         break;
     
807.                     }
     
808.                 }
     
809.                 return tempStr;
     
810.             }
     
811.         }
     
812.         #endregion
     
813. 
     
814.         #region DateHoliday
     
815.         /// <summary>
     
816.         /// 按公历日计算的节日
     
817.         /// </summary>
     
818.         public string DateHoliday
     
819.         {
     
820.             get
     
821.             {
     
822.                 string tempStr = "";
     
823. 
     
824.                 foreach (SolarHolidayStruct sh in sHolidayInfo)
     
825.                 {
     
826.                     if ((sh.Month == _date.Month) && (sh.Day == _date.Day))
     
827.                     {
     
828.                         tempStr = sh.HolidayName;
     
829.                         break;
     
830.                     }
     
831.                 }
     
832.                 return tempStr;
     
833.             }
     
834.         }
     
835.         #endregion
     
836.         #endregion
     
837. 
     
838.         #region 公历日期
     
839.         #region Date
     
840.         /// <summary>
     
841.         /// 取对应的公历日期
     
842.         /// </summary>
     
843.         public DateTime Date
     
844.         {
     
845.             get { return _date; }
     
846.             set { _date = value; }
     
847.         }
     
848.         #endregion
     
849. 
     
850.         #region WeekDay
     
851.         /// <summary>
     
852.         /// 取星期几
     
853.         /// </summary>
     
854.         public DayOfWeek WeekDay
     
855.         {
     
856.             get { return _date.DayOfWeek; }
     
857.         }
     
858.         #endregion
     
859. 
     
860.         #region WeekDayStr
     
861.         /// <summary>
     
862.         /// 周几的字符
     
863.         /// </summary>
     
864.         public string WeekDayStr
     
865.         {
     
866.             get
     
867.             {
     
868.                 switch (_date.DayOfWeek)
     
869.                 {
     
870.                     case DayOfWeek.Sunday:
     
871.                         return "星期日";
     
872.                     case DayOfWeek.Monday:
     
873.                         return "星期一";
     
874.                     case DayOfWeek.Tuesday:
     
875.                         return "星期二";
     
876.                     case DayOfWeek.Wednesday:
     
877.                         return "星期三";
     
878.                     case DayOfWeek.Thursday:
     
879.                         return "星期四";
     
880.                     case DayOfWeek.Friday:
     
881.                         return "星期五";
     
882.                     default:
     
883.                         return "星期六";
     
884.                 }
     
885.             }
     
886.         }
     
887.         #endregion
     
888. 
     
889.         #region DateString
     
890.         /// <summary>
     
891.         /// 公历日期中文表示法 如一九九七年七月一日
     
892.         /// </summary>
     
893.         public string DateString
     
894.         {
     
895.             get
     
896.             {
     
897.                 return "公元" + this._date.ToLongDateString();
     
898.             }
     
899.         }
     
900.         #endregion
     
901. 
     
902.         #region IsLeapYear
     
903.         /// <summary>
     
904.         /// 当前是否公历闰年
     
905.         /// </summary>
     
906.         public bool IsLeapYear
     
907.         {
     
908.             get
     
909.             {
     
910.                 return DateTime.IsLeapYear(this._date.Year);
     
911.             }
     
912.         }
     
913.         #endregion
     
914. 
     
915.         #region ChineseConstellation
     
916.         /// <summary>
     
917.         /// 28星宿计算
     
918.         /// </summary>
     
919.         public string ChineseConstellation
     
920.         {
     
921.             get
     
922.             {
     
923.                 int offset = 0;
     
924.                 int modStarDay = 0;
     
925. 
     
926.                 TimeSpan ts = this._date - ChineseConstellationReferDay;
     
927.                 offset = ts.Days;
     
928.                 modStarDay = offset % 28;
     
929.                 return (modStarDay >= 0 ? _chineseConstellationName[modStarDay] : _chineseConstellationName[27 + modStarDay]);
     
930.             }
     
931.         }
     
932.         #endregion
     
933. 
     
934.         #region ChineseHour
     
935.         /// <summary>
     
936.         /// 时辰
     
937.         /// </summary>
     
938.         public string ChineseHour
     
939.         {
     
940.             get
     
941.             {
     
942.                 return GetChineseHour(_datetime);
     
943.             }
     
944.         }
     
945.         #endregion
     
946. 
     
947.         #endregion
     
948. 
     
949.         #region 农历日期
     
950.         #region IsChineseLeapMonth
     
951.         /// <summary>
     
952.         /// 是否闰月
     
953.         /// </summary>
     
954.         public bool IsChineseLeapMonth
     
955.         {
     
956.             get { return this._cIsLeapMonth; }
     
957.         }
     
958.         #endregion
     
959. 
     
960.         #region IsChineseLeapYear
     
961.         /// <summary>
     
962.         /// 当年是否有闰月
     
963.         /// </summary>
     
964.         public bool IsChineseLeapYear
     
965.         {
     
966.             get
     
967.             {
     
968.                 return this._cIsLeapYear;
     
969.             }
     
970.         }
     
971.         #endregion
     
972. 
     
973.         #region ChineseDay
     
974.         /// <summary>
     
975.         /// 农历日
     
976.         /// </summary>
     
977.         public int ChineseDay
     
978.         {
     
979.             get { return this._cDay; }
     
980.         }
     
981.         #endregion
     
982. 
     
983.         #region ChineseDayString
     
984.         /// <summary>
     
985.         /// 农历日中文表示
     
986.         /// </summary>
     
987.         public string ChineseDayString
     
988.         {
     
989.             get
     
990.             {
     
991.                 switch (this._cDay)
     
992.                 {
     
993.                     case 0:
     
994.                         return "";
     
995.                     case 10:
     
996.                         return "初十";
     
997.                     case 20:
     
998.                         return "二十";
     
999.                     case 30:
     
1000.                         return "三十";
      
1001.                     default:
      
1002.                         return nStr2[(int)(_cDay / 10)].ToString() + nStr1[_cDay % 10].ToString();
      
1003. 
      
1004.                 }
      
1005.             }
      
1006.         }
      
1007.         #endregion
      
1008. 
      
1009.         #region ChineseMonth
      
1010.         /// <summary>
      
1011.         /// 农历的月份
      
1012.         /// </summary>
      
1013.         public int ChineseMonth
      
1014.         {
      
1015.             get { return this._cMonth; }
      
1016.         }
      
1017.         #endregion
      
1018. 
      
1019.         #region ChineseMonthString
      
1020.         /// <summary>
      
1021.         /// 农历月份字符串
      
1022.         /// </summary>
      
1023.         public string ChineseMonthString
      
1024.         {
      
1025.             get
      
1026.             {
      
1027.                 return _monthString[this._cMonth];
      
1028.             }
      
1029.         }
      
1030.         #endregion
      
1031. 
      
1032.         #region ChineseYear
      
1033.         /// <summary>
      
1034.         /// 取农历年份
      
1035.         /// </summary>
      
1036.         public int ChineseYear
      
1037.         {
      
1038.             get { return this._cYear; }
      
1039.         }
      
1040.         #endregion
      
1041. 
      
1042.         #region ChineseYearString
      
1043.         /// <summary>
      
1044.         /// 取农历年字符串如，一九九七年
      
1045.         /// </summary>
      
1046.         public string ChineseYearString
      
1047.         {
      
1048.             get
      
1049.             {
      
1050.                 string tempStr = "";
      
1051.                 string num = this._cYear.ToString();
      
1052.                 for (int i = 0; i < 4; i++)
      
1053.                 {
      
1054.                     tempStr += ConvertNumToChineseNum(num[i]);
      
1055.                 }
      
1056.                 return tempStr + "年";
      
1057.             }
      
1058.         }
      
1059.         #endregion
      
1060. 
      
1061.         #region ChineseDateString
      
1062.         /// <summary>
      
1063.         /// 取农历日期表示法：农历一九九七年正月初五
      
1064.         /// </summary>
      
1065.         public string ChineseDateString
      
1066.         {
      
1067.             get
      
1068.             {
      
1069.                 if (this._cIsLeapMonth == true)
      
1070.                 {
      
1071.                     return "农历" + ChineseYearString + "闰" + ChineseMonthString + ChineseDayString;
      
1072.                 }
      
1073.                 else
      
1074.                 {
      
1075.                     return "农历" + ChineseYearString + ChineseMonthString + ChineseDayString;
      
1076.                 }
      
1077.             }
      
1078.         }
      
1079.         #endregion
      
1080. 
      
1081.         #region ChineseTwentyFourDay
      
1082.         /// <summary>
      
1083.         /// 定气法计算二十四节气,二十四节气是按地球公转来计算的，并非是阴历计算的
      
1084.         /// </summary>
      
1085.         /// <remarks>
      
1086.         /// 节气的定法有两种。古代历法采用的称为"恒气"，即按时间把一年等分为24份，
      
1087.         /// 每一节气平均得15天有余，所以又称"平气"。现代农历采用的称为"定气"，即
      
1088.         /// 按地球在轨道上的位置为标准，一周360°，两节气之间相隔15°。由于冬至时地
      
1089.         /// 球位于近日点附近，运动速度较快，因而太阳在黄道上移动15°的时间不到15天。
      
1090.         /// 夏至前后的情况正好相反，太阳在黄道上移动较慢，一个节气达16天之多。采用
      
1091.         /// 定气时可以保证春、秋两分必然在昼夜平分的那两天。
      
1092.         /// </remarks>
      
1093.         public string ChineseTwentyFourDay
      
1094.         {
      
1095.             get
      
1096.             {
      
1097.                 DateTime baseDateAndTime = new DateTime(1900, 1, 6, 2, 5, 0); //#1/6/1900 2:05:00 AM#
      
1098.                 DateTime newDate;
      
1099.                 double num;
      
1100.                 int y;
      
1101.                 string tempStr = "";
      
1102. 
      
1103.                 y = this._date.Year;
      
1104. 
      
1105.                 for (int i = 1; i <= 24; i++)
      
1106.                 {
      
1107.                     num = 525948.76 * (y - 1900) + sTermInfo[i - 1];
      
1108. 
      
1109.                     newDate = baseDateAndTime.AddMinutes(num);//按分钟计算
      
1110.                     if (newDate.DayOfYear == _date.DayOfYear)
      
1111.                     {
      
1112.                         tempStr = SolarTerm[i - 1];
      
1113.                         break;
      
1114.                     }
      
1115.                 }
      
1116.                 return tempStr;
      
1117.             }
      
1118.         }
      
1119. 
      
1120.         //当前日期前一个最近节气
      
1121.         public string ChineseTwentyFourPrevDay
      
1122.         {
      
1123.             get
      
1124.             {
      
1125.                 DateTime baseDateAndTime = new DateTime(1900, 1, 6, 2, 5, 0); //#1/6/1900 2:05:00 AM#
      
1126.                 DateTime newDate;
      
1127.                 double num;
      
1128.                 int y;
      
1129.                 string tempStr = "";
      
1130. 
      
1131.                 y = this._date.Year;
      
1132. 
      
1133.                 for (int i = 24; i >= 1; i--)
      
1134.                 {
      
1135.                     num = 525948.76 * (y - 1900) + sTermInfo[i - 1];
      
1136. 
      
1137.                     newDate = baseDateAndTime.AddMinutes(num);//按分钟计算
      
1138. 
      
1139.                     if (newDate.DayOfYear < _date.DayOfYear)
      
1140.                     {
      
1141.                         tempStr = string.Format("{0}[{1}]", SolarTerm[i - 1], newDate.ToString("yyyy-MM-dd"));
      
1142.                         break;
      
1143.                     }
      
1144.                 }
      
1145. 
      
1146.                 return tempStr;
      
1147.             }
      
1148. 
      
1149.         }
      
1150. 
      
1151.         //当前日期后一个最近节气
      
1152.         public string ChineseTwentyFourNextDay
      
1153.         {
      
1154.             get
      
1155.             {
      
1156.                 DateTime baseDateAndTime = new DateTime(1900, 1, 6, 2, 5, 0); //#1/6/1900 2:05:00 AM#
      
1157.                 DateTime newDate;
      
1158.                 double num;
      
1159.                 int y;
      
1160.                 string tempStr = "";
      
1161. 
      
1162.                 y = this._date.Year;
      
1163. 
      
1164.                 for (int i = 1; i <= 24; i++)
      
1165.                 {
      
1166.                     num = 525948.76 * (y - 1900) + sTermInfo[i - 1];
      
1167. 
      
1168.                     newDate = baseDateAndTime.AddMinutes(num);//按分钟计算
      
1169. 
      
1170.                     if (newDate.DayOfYear > _date.DayOfYear)
      
1171.                     {
      
1172.                         tempStr = string.Format("{0}[{1}]", SolarTerm[i - 1], newDate.ToString("yyyy-MM-dd"));
      
1173.                         break;
      
1174.                     }
      
1175.                 }
      
1176.                 return tempStr;
      
1177.             }
      
1178. 
      
1179.         }
      
1180.         #endregion
      
1181.         #endregion
      
1182. 
      
1183.         #region 星座
      
1184.         #region Constellation
      
1185.         /// <summary>
      
1186.         /// 计算指定日期的星座序号
      
1187.         /// </summary>
      
1188.         /// <returns></returns>
      
1189.         public string Constellation
      
1190.         {
      
1191.             get
      
1192.             {
      
1193.                 int index = 0;
      
1194.                 int y, m, d;
      
1195.                 y = _date.Year;
      
1196.                 m = _date.Month;
      
1197.                 d = _date.Day;
      
1198.                 y = m * 100 + d;
      
1199. 
      
1200.                 if (((y >= 321) && (y <= 419))) { index = 0; }
      
1201.                 else if ((y >= 420) && (y <= 520)) { index = 1; }
      
1202.                 else if ((y >= 521) && (y <= 620)) { index = 2; }
      
1203.                 else if ((y >= 621) && (y <= 722)) { index = 3; }
      
1204.                 else if ((y >= 723) && (y <= 822)) { index = 4; }
      
1205.                 else if ((y >= 823) && (y <= 922)) { index = 5; }
      
1206.                 else if ((y >= 923) && (y <= 1022)) { index = 6; }
      
1207.                 else if ((y >= 1023) && (y <= 1121)) { index = 7; }
      
1208.                 else if ((y >= 1122) && (y <= 1221)) { index = 8; }
      
1209.                 else if ((y >= 1222) || (y <= 119)) { index = 9; }
      
1210.                 else if ((y >= 120) && (y <= 218)) { index = 10; }
      
1211.                 else if ((y >= 219) && (y <= 320)) { index = 11; }
      
1212.                 else { index = 0; }
      
1213. 
      
1214.                 return _constellationName[index];
      
1215.             }
      
1216.         }
      
1217.         #endregion
      
1218.         #endregion
      
1219. 
      
1220.         #region 属相
      
1221.         #region Animal
      
1222.         /// <summary>
      
1223.         /// 计算属相的索引，注意虽然属相是以农历年来区别的，但是目前在实际使用中是按公历来计算的
      
1224.         /// 鼠年为1,其它类推
      
1225.         /// </summary>
      
1226.         public int Animal
      
1227.         {
      
1228.             get
      
1229.             {
      
1230.                 int offset = _date.Year - AnimalStartYear;
      
1231.                 return (offset % 12) + 1;
      
1232.             }
      
1233.         }
      
1234.         #endregion
      
1235. 
      
1236.         #region AnimalString
      
1237.         /// <summary>
      
1238.         /// 取属相字符串
      
1239.         /// </summary>
      
1240.         public string AnimalString
      
1241.         {
      
1242.             get
      
1243.             {
      
1244.                 int offset = _date.Year - AnimalStartYear; //阳历计算
      
1245.                 //int offset = this._cYear - AnimalStartYear;　农历计算
      
1246.                 return animalStr[offset % 12].ToString();
      
1247.             }
      
1248.         }
      
1249.         #endregion
      
1250.         #endregion
      
1251. 
      
1252.         #region 天干地支
      
1253.         #region GanZhiYearString
      
1254.         /// <summary>
      
1255.         /// 取农历年的干支表示法如 乙丑年
      
1256.         /// </summary>
      
1257.         public string GanZhiYearString
      
1258.         {
      
1259.             get
      
1260.             {
      
1261.                 string tempStr;
      
1262.                 int i = (this._cYear - GanZhiStartYear) % 60; //计算干支
      
1263.                 tempStr = ganStr[i % 10].ToString() + zhiStr[i % 12].ToString() + "年";
      
1264.                 return tempStr;
      
1265.             }
      
1266.         }
      
1267.         #endregion
      
1268. 
      
1269.         #region GanZhiMonthString
      
1270.         /// <summary>
      
1271.         /// 取干支的月表示字符串，注意农历的闰月不记干支
      
1272.         /// </summary>
      
1273.         public string GanZhiMonthString
      
1274.         {
      
1275.             get
      
1276.             {
      
1277.                 //每个月的地支总是固定的,而且总是从寅月开始
      
1278.                 int zhiIndex;
      
1279.                 string zhi;
      
1280.                 if (this._cMonth > 10)
      
1281.                 {
      
1282.                     zhiIndex = this._cMonth - 10;
      
1283.                 }
      
1284.                 else
      
1285.                 {
      
1286.                     zhiIndex = this._cMonth + 2;
      
1287.                 }
      
1288.                 zhi = zhiStr[zhiIndex - 1].ToString();
      
1289. 
      
1290.                 //根据当年的干支年的干来计算月干的第一个
      
1291.                 int ganIndex = 1;
      
1292.                 string gan;
      
1293.                 int i = (this._cYear - GanZhiStartYear) % 60; //计算干支
      
1294.                 switch (i % 10)
      
1295.                 {
      
1296.                     #region ...
      
1297.                     case 0: //甲
      
1298.                         ganIndex = 3;
      
1299.                         break;
      
1300.                     case 1: //乙
      
1301.                         ganIndex = 5;
      
1302.                         break;
      
1303.                     case 2: //丙
      
1304.                         ganIndex = 7;
      
1305.                         break;
      
1306.                     case 3: //丁
      
1307.                         ganIndex = 9;
      
1308.                         break;
      
1309.                     case 4: //戊
      
1310.                         ganIndex = 1;
      
1311.                         break;
      
1312.                     case 5: //己
      
1313.                         ganIndex = 3;
      
1314.                         break;
      
1315.                     case 6: //庚
      
1316.                         ganIndex = 5;
      
1317.                         break;
      
1318.                     case 7: //辛
      
1319.                         ganIndex = 7;
      
1320.                         break;
      
1321.                     case 8: //壬
      
1322.                         ganIndex = 9;
      
1323.                         break;
      
1324.                     case 9: //癸
      
1325.                         ganIndex = 1;
      
1326.                         break;
      
1327.                     #endregion
      
1328.                 }
      
1329.                 gan = ganStr[(ganIndex + this._cMonth - 2) % 10].ToString();
      
1330. 
      
1331.                 return gan + zhi + "月";
      
1332.             }
      
1333.         }
      
1334.         #endregion
      
1335. 
      
1336.         #region GanZhiDayString
      
1337.         /// <summary>
      
1338.         /// 取干支日表示法
      
1339.         /// </summary>
      
1340.         public string GanZhiDayString
      
1341.         {
      
1342.             get
      
1343.             {
      
1344.                 int i, offset;
      
1345.                 TimeSpan ts = this._date - GanZhiStartDay;
      
1346.                 offset = ts.Days;
      
1347.                 i = offset % 60;
      
1348.                 return ganStr[i % 10].ToString() + zhiStr[i % 12].ToString() + "日";
      
1349.             }
      
1350.         }
      
1351.         #endregion
      
1352. 
      
1353.         #region GanZhiDateString
      
1354.         /// <summary>
      
1355.         /// 取当前日期的干支表示法如 甲子年乙丑月丙庚日
      
1356.         /// </summary>
      
1357.         public string GanZhiDateString
      
1358.         {
      
1359.             get
      
1360.             {
      
1361.                 return GanZhiYearString + GanZhiMonthString + GanZhiDayString;
      
1362.             }
      
1363.         }
      
1364.         #endregion
      
1365.         #endregion
      
1366.         #endregion
      
1367. 
      
1368.         #region 方法
      
1369.         #region NextDay
      
1370.         /// <summary>
      
1371.         /// 取下一天
      
1372.         /// </summary>
      
1373.         /// <returns></returns>
      
1374.         public ChineseCalendar NextDay()
      
1375.         {
      
1376.             DateTime nextDay = _date.AddDays(1);
      
1377.             return new ChineseCalendar(nextDay);
      
1378.         }
      
1379.         #endregion
      
1380. 
      
1381.         #region PervDay
      
1382.         /// <summary>
      
1383.         /// 取前一天
      
1384.         /// </summary>
      
1385.         /// <returns></returns>
      
1386.         public ChineseCalendar PervDay()
      
1387.         {
      
1388.             DateTime pervDay = _date.AddDays(-1);
      
1389.             return new ChineseCalendar(pervDay);
      
1390.         }
      
1391.         #endregion
      
1392.         #endregion
      
1393.     }
      
1394. }
      

复制代码

调用：

1. DateTime dt = DateTime.Now;
   
2. ChineseCalendar cc = new ChineseCalendar(dt);
   
3. Console.WriteLine("阳历：" + cc.DateString);
   
4. Console.WriteLine("属相：" + cc.AnimalString);
   
5. Console.WriteLine("农历：" + cc.ChineseDateString);
   
6. Console.WriteLine("时辰：" + cc.ChineseHour);
   
7. Console.WriteLine("节气：" + cc.ChineseTwentyFourDay);
   
8. Console.WriteLine("节日：" + cc.DateHoliday);
   
9. Console.WriteLine("前一个节气：" + cc.ChineseTwentyFourPrevDay);
   
10. Console.WriteLine("后一个节气：" + cc.ChineseTwentyFourNextDay);
    
11. Console.WriteLine("干支：" + cc.GanZhiDateString);
    
12. Console.WriteLine("星期：" + cc.WeekDayStr);
    
13. Console.WriteLine("星宿：" + cc.ChineseConstellation);
    
14. Console.WriteLine("星座：" + cc.Constellation);

复制代码

结果：

1. 阳历：公元2013年1月27日
   
2. 属相：蛇
   
3. 农历：农历二零一二年腊月十六
   
4. 时辰：庚申
   
5. 节气：
   
6. 节日：
   
7. 前一个节气：大寒[2013-01-20]
   
8. 后一个节气：立春[2013-02-03]
   
9. 干支：壬辰年癸丑月癸巳日
   
10. 星期：星期日
    
11. 星宿：房日兔
    
12. 星座：水瓶座

复制代码