`
jilong-liang
  • 浏览: 482478 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类

最全C#时间处理通用类（DateTimeHelper）

    博客分类：
  • C #
C# 
阅读更多 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Utility
{
    /// <summary>
    /// <Author>梁继龙</Author>
    /// <Date>2012/8/10</Date>
    /// <Language>C Sharp</Language>
    /// <Description>处理时间</Description> 
    /// </summary>
    public class DateTimeHelper
    { 
        /// 创建一个DateTime
        private static DateTime dt = DateTime.Now;
        static  DateTimeHelper instance = null;
        //创建一个对象
        private static readonly object lockObj = new object();
        public DateTimeHelper()
        {
            //System.Globalization.CultureInfo cultureInfo = new System.Globalization.CultureInfo("zh-CN", true);
            //cultureInfo.DateTimeFormat.ShortDatePattern = "yyyy-MM-dd";
            //cultureInfo.DateTimeFormat.FullDateTimePattern = "yyyy-MM-dd HH:mm:ss";
            //System.Threading.Thread.CurrentThread.CurrentCulture = cultureInfo;

        }
        /// <summary>
        /// 单例模式
        /// </summary>
        /// <returns></returns>
        public static DateTimeHelper GetInstance()
        {
            //lock (AccessFileHelper.instance){ }
            if (instance == null)
            {
                lock (lockObj)
                {
                    instance = new DateTimeHelper();
                }
            }
            return instance;
        }
       
        /// <summary>
        /// 纯粹返回一个string的DateTime
        /// </summary>
        /// <returns>返回结果如2012-8-10 12:47:04 </returns>
        public static string GetDateTimeNow()
        {
            return dt.ToString();
        }
        /// <summary>
        /// 返回一个string字符串的时间
        /// </summary>
        /// <returns> 返回结果如: 2012-8-10 13:21:25 </returns>
        public static string GetString_DateTime()
        {
            return dt.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToFileTime方法
        /// ToFileTime这个是返回一个long类型
        /// </summary>
        /// <returns>返回结果如: 127756416859912816 </returns>
        public static string GetToFile_DateTime()
        {
            return dt.ToFileTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToFileTimeUtc方法
        /// ToFileTimeUtc这个是返回一个long类型
        /// </summary>
        /// <returns>返回结果如:127756704859912816 </returns>
        public static string GetToFileUtc_DateTime()
        {
            return dt.ToFileTimeUtc().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLocalTime方法
        /// </summary>
        /// <returns>返回结果如:2012-8-10 21:21:25 </returns>
        public static string GetToLocalDate_DateTime()
        {
            return dt.ToLocalTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLongDateString方法
        /// </summary>
        /// <returns>返回一个格式为：2012年8月10日</returns>
        public static string GetToLongDateStr_DateTime()
        {
            return dt.ToLongDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLongTimeString方法
        /// </summary>
        /// <returns>返回结果如：13:21:25 </returns>
        public static string GetToLongTimeStr_DateTime()
        {
            return dt.ToLongTimeString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToOADate方法
        /// </summary>
        /// <returns>返回结果如:38661.5565508218 </returns>
        public static string GetToOADate_DateTime()
        {
            return dt.ToOADate().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到今天ToDay
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_ToDay()
        {
            //return dt.ToShortDateString().ToString();
            return dt.Date.ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到昨天Yesterday
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_Yesterday()
        {
            return dt.Date.AddDays(-1).ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到明天Tomorrow
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_Tomorrow()
        {
            return dt.Date.AddDays(1).ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// </summary>
        /// <returns>返回结果如: 13:21 </returns>
        public static string GetToShortTimeStr_DateTime()
        {
            return dt.ToShortTimeString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToUniversalTime方法
        /// </summary>
        /// <returns>返回结果如：2012-8-10 5:21:25</returns>
        public static string GetToUniversalTime_DateTime()
        {
            return dt.ToUniversalTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的封装类Year类
        /// </summary>
        /// <returns>返回结果如：2012</returns>
        public static string GetYear()
        {
            return dt.Year.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的Date
        /// </summary>
        /// <returns>返回结果如：2012-8-12 0:00:00</returns>
        public static string GetDate()
        {
            return dt.Date.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的一周的星期几
        /// DayOfWeek是一个枚举
        /// </summary>
        /// <returns>返回结果如：FriDay </returns>
        public static string GetDayOfWeek()
        {
            return dt.DayOfWeek.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的DayOfYear
        /// DayOfYear是一个枚举
        /// </summary>
        /// <returns>返回结果如:309  </returns>
        public static string GetDayOfYear()
        {
            return dt.DayOfYear.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的小时
        /// 小时组成部分，表示为 0 和 23 之间的一个值。
        /// </summary>
        /// <returns>返回结果如:12</returns>
        public static string GetHour()
        {
            return dt.Hour.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的毫秒
        /// 毫秒组成部分，表示为 0 和 999 之间的一个值.
        /// </summary>
        /// <returns>返回结果如:120</returns>
        public static string GetMillisecond()
        {
            return dt.Millisecond.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的分钟
        /// 分钟组成部分，表示为 0 和 59 之间的一个值.
        /// </summary>
        /// <returns>返回结果如:23</returns>
        public static string GetMinute()
        {
            return dt.Minute.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的月份
        /// 月组成部分，表示为 1 和 12 之间的一个值。
        /// </summary>
        /// <returns>返回结果如:8</returns>
        public static string GetMonth()
        {
            return dt.Month.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的秒数
        /// 秒数(介于 0 和 59 之间).
        /// </summary>
        /// <returns>返回结果如:12</returns>
        public static string GetSecond()
        {
            return dt.Second.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的周期数
        /// 表示此实例的日期和时间的计时周期数
        /// 该值介于 DateTime.MinValue.Ticks 和 DateTime.MaxValue.Ticks
        /// </summary>
        /// <returns>返回结果如:632667942284412864 </returns>
        public static string GetTicks()
        {
            return dt.Ticks.ToString();
        }
        /// <summary>
        ///  System.TimeSpan它表示当天自午夜以来已经过时间的部分。
        /// </summary>
        /// <returns>返回结果如:13:30:28.4412864</returns>
        public static string GetTimeOfDay()
        {
            return dt.TimeOfDay.ToString();
        }
        /// <summary>
        /// 此方法封装获取明年当前时间.
        /// 说白就是在本年添加一
        /// </summary>
        /// <returns>返回的结果如：2013-11-5 13:47:04</returns>
        public static string GetAddOneYears()
        {
            return dt.AddYears(1).ToString();
        }
        /// <summary>
        /// 此方法在当天添加1.1Day
        /// 可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>返回的结果如:2012-8-11 16:11:04 </returns>
        public static string GetAddDays()
        {
            try
            {
                return dt.AddDays(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 此方法在当前时间添加1.1个小时
        ///可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>返回的结果如:2012-8-10 16:11:04 </returns>
        public static string GetAddHours()
        {
            try
            {
                return dt.AddHours(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 此方法在当前时间添加1.1毫秒
        /// 可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns></returns>
        public static string GetAddMilliseconds()
        {
            try
            {
                return dt.AddMilliseconds(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///在当前月添加一个月
        ///异常:System.ArgumentOutOfRangeException:
        ///所生成的 System.DateTime 小于 System.DateTime.MinValue 或大于 System.DateTime.MaxValue。
        ///- 或 - months 小于 -120,000 或大于 120,000。
        /// </summary>
        /// <returns>返回的结果如:2012-08-11 13:47:04 </returns>
        public static string GetAddMonths()
        {
            try
            {
                return dt.AddMonths(1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 在当前秒数基础上添加一1.1秒数
        /// System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>2012-08-10 13:47:05 </returns>
        public static string GetAddSeconds()
        {
            try
            {
                return dt.AddSeconds(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 在当前时间上添加1.1分钟
        /// </summary>
        /// <returns></returns>
        public static string GetAddMinutes()
        {
            try
            {
                return dt.AddMinutes(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将指定1000的计时周期数加到此实例的值上
        /// </summary>
        /// <returns></returns>
        public static string GetAddTicks()
        {
            try
            {
                return dt.AddTicks(1000).ToString();//2005-11-5 13:47:04 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 比较时间
        /// 有符号数字，指示此实例和 value 参数的相对值 值 说明 小于零 此实例早于 value.
        /// 零 此实例与 value 相同.大于零 此实例晚于
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public static string GetCompareTo(DateTime dateTime)
        {
            return dt.CompareTo(dateTime).ToString();
        }
        /// <summary>
        /// 指定时间判断是否相等
        /// </summary>
        /// <param name="dateTime">该值指示此实例是否与指定的对象相等</param>
        /// <returns>返回的结果:true/false</returns>
        public static string GetEquals(string dateTime)
        {
            return dt.Equals(dateTime).ToString();
        }
        /// <summary>
        /// 获取一个GetHashCode字符串
        /// </summary>
        /// <returns></returns>
        public static string GetHashCode_DateTime()
        {
            return dt.GetHashCode().ToString();//1474088234 
        }
        /// <summary>
        /// 获取当前时间类型
        /// </summary>
        /// <returns></returns>
        public static string GetDateTimeType()
        {
            return dt.GetType().ToString();//System.DateTime 
        }
        /// <summary>
        /// 获取当前时间类型码
        /// </summary>
        /// <returns></returns>
        public static string GetDateTimeTypeCode()
        {
            return dt.GetTypeCode().ToString();//System.DateTime 
        }
        /**
         * ============================GetDateTimeFormats处理DateTime============================
         */
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012-08-10T14:06:25 </returns>
        public static string GetDateTimeFormats_S()
        {
            try
            {
                return dt.GetDateTimeFormats('s')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// <returns>返回结果如：14:06  </returns>
        ///</summary>
        public static string GetDateTimeFormats_T()
        {
            try
            {
                return dt.GetDateTimeFormats('t')[0].ToString();//14:06 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        ///  </summary>
        /// <returns>返回结果如：2012年08月  </returns>
        public static string GetDateTimeFormats_Y()
        {
            try
            {
                return dt.GetDateTimeFormats('y')[0].ToString();//
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012年08月10日</returns>
        public static string GetDateTimeFormats_D_Index0()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012年08月10日</returns>
        public static string GetDateTimeFormats_D_Index1()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[1].ToString();//2005 11 05 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///  format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：星期六 2012 08 10 </returns>
        public static string GetDateTimeFormats_D_Index2()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[2].ToString();//2005 11 05 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>/星期六 2012年08月10日 </returns>
        public static string GetDateTimeFormats_D_Index3()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[3].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>//08月10日  </returns>
        public static string GetDateTimeFormats_M()
        {
            try
            {
                return dt.GetDateTimeFormats('M')[0].ToString();//11月5日 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>2012年08月10日 14:06  </returns>
        public static string GetDateTimeFormats_F()
        {
            try
            {
                return dt.GetDateTimeFormats('f')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>Result Example:2012-08-10 14:06 </returns>
        public static string GetDateTimeFormats_G()
        {
            try
            {
                return dt.GetDateTimeFormats('g')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        ///</summary>
        /// <returns>Result Example:Fri,10 Aug 2010 14:06:25 GMT</returns>
        public static string GetDateTimeFormats_R()
        {
            try
            {
                return dt.GetDateTimeFormats('r')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /**
         *====================================GetFromat处理DateTime=============================
         * 
         */
        /// <summary>
        /// 异常:
        ///System.ArgumentNullException:
        ///format 为 null
        ///System.FormatException:
        ///format 中的格式项无效 - 或 - 用来表示要格式化的参数的数字小于零或者大于等于要格式化的指定对象的数目。
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23 </returns>
        public static string GetFromat()
        {
            try
            {
                //return string.Format("{0}", dt);//效果一样
                return dt.ToString("{0}", DateTimeFormatInfo.InvariantInfo);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 异常:
        ///System.ArgumentNullException:
        ///format 为 null
        ///System.FormatException:
        ///format 中的格式项无效 - 或 - 用来表示要格式化的参数的数字小于零或者大于等于要格式化的指定对象的数目。
        /// </summary>
        /// <returns>result:2012-08-10</returns>
        public static string GetFromat_d()
        {
            try
            {
                return string.Format("{0:d}", dt);//2005-11-5 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日</returns>
        public static string GetFromat_D()
        {
            try
            {
                return string.Format("{0:D}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 14:23 </returns>
        public static string GetFromat_f()
        {
            try
            {
                return string.Format("{0:f}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 14:23 </returns>
        public static string GetFromat_F()
        {
            try
            {
                return string.Format("{0:F}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23 </returns>
        public static string GetFromat_g()
        {
            try
            {
                return string.Format("{0:g}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23</returns>
        public static string GetFromat_G()
        {
            try
            {
                return string.Format("{0:G}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:08月10日</returns>
        public static string GetFromat_M()
        {
            try
            {
                return string.Format("{0:M}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:Fri,10 Aug 2010 14:06:25 GMT</returns>
        public static string GetFromat_R()
        {
            try
            {
                return string.Format("{0:R}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10T14:23:23</returns>
        public static string GetFromat_s()
        {
            try
            {
                return string.Format("{0:s}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:14:23</returns>
        public static string GetFromat_t()
        {
            try
            {
                return string.Format("{0:t}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:14:23:23</returns>
        public static string GetFromat_T()
        {
            try
            {
                return string.Format("{0:T}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23Z</returns>
        public static string GetFromat_u()
        {
            try
            {
                return string.Format("{0:u}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 6:23:23</returns>
        public static string GetFromat_U()
        {
            try
            {
                return string.Format("{0:U}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月</returns>
        public static string GetFromat_Y()
        {
            try
            {
                return string.Format("{0:Y}", dt);
            }
            catch (Exception)
            {
                throw;
            }

        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月</returns>
        public static string GetFromat_yyyyMMddHHmmssffff()
        {
            try
            {
                return string.Format("{0:yyyyMMddHHmmssffff}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本周第一天日期
        /// 星期天为第一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekFirstDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((0 - Convert.ToInt16(DateTime.Now.DayOfWeek))))
                    .ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本周最后一天日期
        /// DateTime.Now.AddDays(7).ToShortDateString();//7天后
        ///DateTime.Now.AddDays(-7).ToShortDateString();7天前
        /// 周六为最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekLastDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((6 - Convert.ToInt16(DateTime.Now.DayOfWeek))))
                    .ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 用数组处理获取本周当日为星期几
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekDay()
        {
            try
            {
                string[] Day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
                return Day[Convert.ToInt16(DateTime.Now.DayOfWeek)];
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上周第一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeWeekFirstDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((0 - Convert.ToInt16(DateTime.Now.DayOfWeek))) - 7).ToShortDateString();
                  
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上周最后一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeWeekLastDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((6 - Convert.ToInt16(DateTime.Now.DayOfWeek))) - 7)
                    .ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下周第一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetNextWeekFirstDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((0 - Convert.ToInt16(DateTime.Now.DayOfWeek))) + 7).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下周最后一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetNextWeekLastDay()
        {
            try
            {
                return DateTime.Now.AddDays(Convert.ToDouble((6 - Convert.ToInt16(DateTime.Now.DayOfWeek))) + 7).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本个月的第一天
        /// DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + "1";
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentMonthFirstDay()
        {
            try
            {
                return DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + "1";
               //return DateTime.Now.ToString("yyyy-MM-01");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本个月的最后一天
        /// 这个处理有异常.
        /// DateTime.Parse(DateTime.Now.Year.ToString() +
        /// DateTime.Now.Month.ToString() + "1").AddMonths(1).AddDays(-1).ToShortDateString();
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentMonthLastDay()
        {
            try
            {
                ////建议使用这个
                return DateTime.Parse(DateTime.Now.ToString("yyyy-MM-01")).AddMonths(1).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上个月的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeMonthFirstDay()
        {
            try
            {
                //return DateTime.Parse(DateTime.Now.ToString("yyyy-MM-01")).AddMonths(-1).ToShortDateString();
                return DateTime.Now.AddMonths(0 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01"); ;//与上面效果一样
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上个月的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeMonthLastDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
                //或者 return DateTime.Parse(DateTime.Now.AddMonths(1 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下个月的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextMonthFirstDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-MM-01")).AddMonths(1).ToShortDateString();
                //或者return DateTime.Now.AddMonths(2 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01");

            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下个月的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextMonthLastDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-MM-01")).AddMonths(2).AddDays(-1).ToShortDateString();
                //或者 return DateTime.Now.AddMonths(2 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01");
                //或者return DateTime.Parse(DateTime.Now.AddMonths(3 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentYearFirstDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentYearLastDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).AddYears(1).AddDays(-1).ToShortDateString();
                //或者return DateTime.Parse(DateTime.Now.AddMonths(6 - ((DateTime.Now.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取去年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeYearFirstDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).AddYears(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取去年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeYearLastDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取明年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextYearFirstDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).AddYears(1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取明年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextYearLastDay()
        {
            try
            {
                return DateTime.Parse(DateTime.Now.ToString("yyyy-01-01")).AddYears(2).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}

 

  • 大小: 161.6 KB
分享到：
| C# 与JSE的单例设计模式的区别
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C# .Net通用工具类

    "C# .Net通用工具类"是一个集合了各种实用功能的代码库，它旨在简化常见的编程任务，提高开发效率。这个工具类集合可能是由开发者们在实际项目中提炼和优化的代码片段组成，便于其他开发者在自己的项目中直接引用和...

    C# 常用公共类库

    4. **CCalendar.cs**: 这个类可能涉及日期和时间的处理，包括日期计算、节假日判断、时区转换等功能，帮助开发者更好地管理和操作日期和时间数据。 5. **CString.cs**: 另一个字符串操作的类，可能包含更高级的字符...

    C#帮助类、各种基类等

    在C#编程中，帮助类（Helper Class）和基类（Base Class）是两种非常重要的设计模式，它们有助于代码的组织、复用和扩展。帮助类通常包含一系列静态方法，提供通用的功能，而基类则作为派生类的起点，为子类提供共享...

    C#基类/工具类

    描述中提到的“各种辅助工具类”通常是指一系列静态类，这些类包含各种实用方法，用于处理字符串、日期时间、数学计算、文件操作、网络请求等各种常见任务。工具类的使用可以大大简化代码，使代码更易读、易维护。...

    C#基础工具类集合，DLL

    这些工具类通常包含了各种实用方法，如字符串处理、日期时间操作、数学计算、文件系统操作等。下面将详细介绍C#中创建和使用工具类集合的一些关键知识点。 1. **类库项目与DLL文件** - 在Visual Studio中，我们...

    100个C#辅助类

    在C#编程中，辅助类（Helper Class）是一种常见的设计模式，它用于封装一组相关或通用的功能，使得代码更加模块化、可复用且易于维护。"100个C#辅助类"这个主题涵盖了广泛的功能，每个辅助类可能解决一个特定的问题...

    输出当前系统时间

    此外，C#还提供了一些预定义的日期和时间格式，如`"G"`（通用格式）、`"d"`（短日期格式）、`"t"`（短时间格式）等。例如： ```csharp string generalFormat = currentTime.ToString("G"); string shortDateFormat ...

    我每天使用的.NET辅助方法和类的集合 我将它们打包在一个库中以避免代码重复 -C#-下载

    2. **DateTimeHelper**：提供了日期和时间处理的便捷方法，例如计算两个日期之间的差值、格式化日期字符串等。 3. **TypeConverter**：用于在不同数据类型之间进行转换，例如从字符串到数字，或者从枚举到其对应的...

    C sharp辅助类

    2. **日期和时间**：日期和时间的处理是常见的需求，`DateTimeHelper`类可能包含`GetNow`获取当前时间，`AddDays`、`AddMonths`等方法进行日期运算。 3. **集合操作**：集合类的辅助方法可以帮助开发者处理数组、...

Magicbox
Global site tag (gtag.js) - Google Analytics