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

最新推荐文章于 2022-05-25 09:43:57 发布
最新推荐文章于 2022-05-25 09:43:57 发布 · 1.1k 阅读 · 0
文章标签：

#C#

本文介绍了一个C#中的DateTime辅助工具类，包括日期时间的格式化、时间加减操作、日期范围获取等功能。提供了丰富的示例方法，帮助开发者快速处理日期时间相关任务。 
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;
            }
        }
    }
}

 

计算两个时间的差值
CoffeMilk的博客
08-17 647
一、实现效果 说明:开始时间为：【2021-08-15 10:26:21】；结束时间为：【2021-08-17 21:31:58】 1.1、计算相差的天数 1.2、计算相差的小时数 1.3、计算相差的分钟数 1.4、计算相差的秒数 二、实现核心 /*** * Title："基础工具" 项目 * 主题：DateTime帮助类 * Description： * 功能： * 1、获取相差的天 * 2、获取相差的小时 * ...
用于查询的日期类型转换帮助类DateTimeHelper.cs
07-25
用于查询的日期类型转换帮助类DateTimeHelper.cs * 描 述：日期转换帮助类，常用于报表开发; * 可以转换成为：本日开始时间、本日结束时间、本周开始时间、本周结束时间、本月开始时间、本月结束时间、本年开始时间、本年结束时间 *
【C#公共帮助类】DateTimeHelper设置电脑本地时间，实际开发很需要
weixin_33910759的博客
08-10 289
关于本文档的说明 　　本文档主要为了解决实际开发当中，服务器和客户端电脑时间不能相等的问题，纯干货，实际项目这种时间不同步的情况很多很多，时间不相等，到时候把本地的数据提交给服务器，服务器看实际上传时间和我写入数据库时间相差好大，影响实际业务操作和判断业务准确性，所以需要设置设备或者电脑的时间来为上传提供准确的时间节点。 　　欢迎传播分享，必须保持原作者的信息，但禁止将该文档直接用...
DateHelper.cs日期时间操作辅助类C#
shan1774965666的专栏
08-01 2177
//==================================================================== //** Copyright © classbao.com 2016 -- QQ:1165458780 -- 请保留此注释 ** //============================================================
C# DateTimeHelper类：高效时间处理解决方案
在介绍“最全C#时间处理通用类（DateTimeHelper）”之前，我们先来了解一下C#中处理时间的基础知识和通用类的概念。 C#是一种面向对象的编程语言，内置了丰富的类库以支持开发者进行各种编程任务。在.NET框架中，...
C# .Net通用工具类
07-20
"C# .Net通用工具类"是一个集合了各种实用功能的代码库，它旨在简化常见的编程任务，提高开发效率。这个工具类集合可能是由开发者们在实际项目中提炼和优化的代码片段组成，便于其他开发者在自己的项目中直接引用和...
C#基础工具类集合，DLL
09-09
这些工具类通常包含了各种实用方法，如字符串处理、日期时间操作、数学计算、文件系统操作等。下面将详细介绍C#中创建和使用工具类集合的一些关键知识点。 1. **类库项目与DLL文件** - 在Visual Studio中，我们...
C#.NET通用工具类库，提升开发效率的必备助手
这套经过“验证无误”的C#通用工具类，正是为此而生——它不是简单的代码片段堆砌，而是融合了多年实战经验的最佳实践结晶。无论是个人开发者还是大型研发团队，都能从中获得实实在在的价值：缩短原型开发周期、减少...
DateHelper
anchenyanyue的专栏
06-15 1980
using System; using System.Collections.Generic; using System.Text; namespace XXXX.Common { public class DateHelper { /// /// 获取指定年份的最大周数 /// /// 年份 /
C#，一份非常实用的DataHelper类
04-02
C#，一份非常实用的DataHelper类，自己收集了一年多的帮助类。，自己收集了一年多的帮助类。，自己收集了一年多的帮助类。
asp.net(C#)常用时间日期处理类
diehe5608的博客
01-24 172
using System; using System.Data; using System.Configuration; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.WebControls; using System.Web.UI.WebC...
DateTimeHelper扩展类
张云勇
11-13 868
public enum RoundTo { Second, Minute, Hour, Day } public static class DateTimeHelper { public static string DefaultFormat; static DateTimeHelper() { DefaultFor
DateTimeHelper【日期类型与字符串互转以及日期对比相关操作】
weixin_34306676的博客
05-21 207
版权声明：本文为HaiyuKing原创文章，转载请注明出处！ 前言 实现日期和字符串之间的转换以及日期的相关操作： 1、日期格式的字符串输出为Date类型； 2、将Date类型以指定格式输出； 3、将日期格式的字符串以指定格式输出； 4、将时间戳转化为固定格式的日期字符串 ； 5、将时间戳转化为指定格式日期的字符串； 6、当前时间提前一个月； 7、当前时间延后一个月； 。。。。...
DatetimeHelper，时间帮助类
weixin_30824277的博客
07-20 239
public static class DateTimeEx { /// <summary> /// 得到中文形式的日期 /// </summary> /// <param name="dt"></param> /// <returns></returns...
C#--时间处理
Schaffer的博客
05-25 582
1、获取当前时间 //获取自定义样式完整时间 DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss.fff"); //2019-12-24 02:57:37.149 //获取日期+时间 DateTime.Now.ToString(); // 2008-9-4 20:02:10 DateTime.Now.ToLocalTime().ToString(); // 2008-9-4 20:12:12 //获取日期 DateTime.Now.T
DateTimeHelper
weixin_34184158的博客
11-14 175
本文参考文章： http://geekswithblogs.net/mnf/articles/my-datetimehelper-class.aspx https://referencesource.microsoft.com/#PresentationFramework/src/Framework/System/Windows/Controls/DateTimeHelper.cs,183 ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值