DateTimeHelper扩展类

using System;
using System.Globalization;
using System.Threading;
 
namespace TestBjDs
{
    public static class DateTimeHelper
    {
        public static string DefaultFormat;
 
        static DateTimeHelper()
        {
            DefaultFormat = "yyyy-MM-dd";
        }
 
        public static DateTime AddBusinessDays(this DateTime current, int days)
        {
            int num = Math.Sign(days);
            int num1 = Math.Abs(days);
            for (int i = 0; i < num1; i++)
            {
                do
                {
                    current = current.AddDays(num);
                } while (current.DayOfWeek == DayOfWeek.Saturday || current.DayOfWeek == DayOfWeek.Sunday);
            }
            return current;
        }
 
        public static DateTime At(this DateTime current, int hour, int minute)
        {
            return current.SetTime(hour, minute);
        }
 
        public static DateTime At(this DateTime current, int hour, int minute, int second)
        {
            return current.SetTime(hour, minute, second);
        }
 
        public static DateTime At(this DateTime current, int hour, int minute, int second, int milliseconds)
        {
            return current.SetTime(hour, minute, second, milliseconds);
        }
 
        public static DateTime BeginningOfDay(this DateTime date)
        {
            return new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, 0, date.Kind);
        }
 
        public static DateTime BeginningOfDay(this DateTime date, int timezoneOffset)
        {
            DateTime dateTime = new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, 0, date.Kind);
            return dateTime.AddHours(timezoneOffset);
        }
 
        public static DateTime DecreaseTime(this DateTime startDate, TimeSpan toSubtract)
        {
            return startDate - toSubtract;
        }
 
        public static DateTime EndOfDay(this DateTime date)
        {
            return new DateTime(date.Year, date.Month, date.Day, 23, 59, 59, 999, date.Kind);
        }
 
        public static DateTime EndOfDay(this DateTime date, int timeZoneOffset)
        {
            DateTime dateTime = new DateTime(date.Year, date.Month, date.Day, 23, 59, 59, 999, date.Kind);
            return dateTime.AddHours(timeZoneOffset);
        }
 
        public static DateTime FirstDayOfMonth(this DateTime current)
        {
            return current.SetDay(1);
        }
 
        public static DateTime FirstDayOfQuarter(this DateTime current)
        {
            int month = (current.Month - 1) / 3 + 1;
            DateTime dateTime = new DateTime(current.Year, 3 * month - 2, 1);
            return current.SetDate(dateTime.Year, dateTime.Month, dateTime.Day);
        }
 
        public static DateTime FirstDayOfWeek(this DateTime dateTime)
        {
            DayOfWeek firstDayOfWeek = Thread.CurrentThread.CurrentCulture.DateTimeFormat.FirstDayOfWeek;
            int dayOfWeek = (int) dateTime.DayOfWeek + ((int) dateTime.DayOfWeek - (int) firstDayOfWeek < (int) DayOfWeek.Sunday ? 7 : 0) - (int) firstDayOfWeek;
            return dateTime.AddDays(-dayOfWeek);
        }
 
        public static DateTime FirstDayOfYear(this DateTime current)
        {
            return current.SetDate(current.Year, 1, 1);
        }
 
        public static int GetDateTimeMonthDifference(DateTime startDate, DateTime endDate)
        {
            int month;
            try
            {
                int year = (endDate.Year - startDate.Year) * 12;
                month = endDate.Month - startDate.Month + year;
            }
            catch (Exception exception)
            {
                throw exception;
            }
            return month;
        }
 
        public static DateTime IncreaseTime(this DateTime startDate, TimeSpan toAdd)
        {
            return startDate + toAdd;
        }
 
        public static bool IsAfter(this DateTime current, DateTime toCompareWith)
        {
            return current > toCompareWith;
        }
 
        public static bool IsBefore(this DateTime current, DateTime toCompareWith)
        {
            return current < toCompareWith;
        }
 
        public static bool IsBetweenTwoTimes(this DateTime current, DateTime time1, DateTime time2)
        {
            DateTime dateTime = time1 > time2 ? time2 : time1;
            DateTime dateTime1 = time1 < time2 ? time2 : time1;
            if (current <= dateTime)
            {
                return false;
            }
            return current < dateTime1;
        }
 
        public static bool IsBiggerThan(this DateTime current, DateTime dateTime)
        {
            return current > dateTime;
        }
 
        public static bool IsInFuture(this DateTime dateTime)
        {
            return dateTime > DateTime.Now;
        }
 
        public static bool IsInPast(this DateTime dateTime)
        {
            return dateTime < DateTime.Now;
        }
 
        public static DateTime LastDayOfMonth(this DateTime current)
        {
            return current.SetDay(DateTime.DaysInMonth(current.Year, current.Month));
        }
 
        public static DateTime LastDayOfQuarter(this DateTime current)
        {
            int month = (current.Month - 1) / 3 + 1;
            DateTime dateTime = current.SetDate(current.Year, 3 * month - 2, 1);
            return dateTime.SetMonth(dateTime.Month + 2).LastDayOfMonth();
        }
 
        public static DateTime LastDayOfWeek(this DateTime current)
        {
            return current.FirstDayOfWeek().AddDays(6);
        }
 
        public static DateTime LastDayOfYear(this DateTime current)
        {
            return current.SetDate(current.Year, 12, 31);
        }
 
        public static DateTime Next(this DateTime start, DayOfWeek day)
        {
            do
            {
                start = start.NextDay();
            } while (start.DayOfWeek != day);
            return start;
        }
 
        public static DateTime NextDay(this DateTime start)
        {
            return start.AddDays(1);
        }
 
        public static DateTime NextMonth(this DateTime current)
        {
            int num = current.Month == 12 ? current.Year + 1 : current.Year;
            DateTime dateTime = current.SetDate(num, current.Month == 12 ? 1 : current.Month + 1, 1);
            int day = dateTime.LastDayOfMonth().Day;
            return dateTime.SetDay(current.Day > day ? day : current.Day);
        }
 
        public static DateTime NextWeek(this DateTime start)
        {
            return start.AddDays(7);
        }
 
        public static DateTime NextYear(this DateTime start)
        {
            int year = start.Year + 1;
            int num = DateTime.DaysInMonth(year, start.Month);
            if (num >= start.Day)
            {
                return new DateTime(year, start.Month, start.Day, start.Hour, start.Minute, start.Second, start.Millisecond, start.Kind);
            }
            int day = start.Day - num;
            DateTime dateTime = new DateTime(year, start.Month, num, start.Hour, start.Minute, start.Second, start.Millisecond, start.Kind);
            return dateTime.AddDays(day);
        }
 
        public static DateTime Noon(this DateTime value)
        {
            return value.SetTime(12, 0, 0, 0);
        }
 
        public static DateTime Previous(this DateTime start, DayOfWeek day)
        {
            do
            {
                start = start.PreviousDay();
            } while (start.DayOfWeek != day);
            return start;
        }
 
        public static DateTime PreviousDay(this DateTime start)
        {
            return start.AddDays(-1);
        }
 
        public static DateTime PreviousMonth(this DateTime current)
        {
            int num = current.Month == 1 ? current.Year - 1 : current.Year;
            DateTime dateTime = current.SetDate(num, current.Month == 1 ? 12 : current.Month - 1, 1);
            int day = dateTime.LastDayOfMonth().Day;
            return dateTime.SetDay(current.Day > day ? day : current.Day);
        }
 
        public static DateTime PreviousWeek(this DateTime start)
        {
            return start.AddDays(-7);
        }
 
        public static DateTime PreviousYear(this DateTime start)
        {
            int year = start.Year - 1;
            int num = DateTime.DaysInMonth(year, start.Month);
            if (num >= start.Day)
            {
                return new DateTime(year, start.Month, start.Day, start.Hour, start.Minute, start.Second, start.Millisecond, start.Kind);
            }
            int day = start.Day - num;
            DateTime dateTime = new DateTime(year, start.Month, num, start.Hour, start.Minute, start.Second, start.Millisecond, start.Kind);
            return dateTime.AddDays(day);
        }
 
        public static DateTime Round(this DateTime dateTime, RoundTo rt)
        {
            DateTime dateTime1;
            switch (rt)
            {
                case RoundTo.Second:
                {
                    dateTime1 = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Kind);
                    if (dateTime.Millisecond < 500)
                    {
                        break;
                    }
                    dateTime1 = dateTime1.AddSeconds(1);
                    break;
                }
                case RoundTo.Minute:
                {
                    dateTime1 = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0, dateTime.Kind);
                    if (dateTime.Second < 30)
                    {
                        break;
                    }
                    dateTime1 = dateTime1.AddMinutes(1);
                    break;
                }
                case RoundTo.Hour:
                {
                    dateTime1 = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 0, 0, dateTime.Kind);
                    if (dateTime.Minute < 30)
                    {
                        break;
                    }
                    dateTime1 = dateTime1.AddHours(1);
                    break;
                }
                case RoundTo.Day:
                {
                    dateTime1 = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0, dateTime.Kind);
                    if (dateTime.Hour < 12)
                    {
                        break;
                    }
                    dateTime1 = dateTime1.AddDays(1);
                    break;
                }
                default:
                {
                    throw new ArgumentOutOfRangeException("rt");
                }
            }
            return dateTime1;
        }
 
        public static DateTime SetDate(this DateTime value, int year)
        {
            return new DateTime(year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SetDate(this DateTime value, int year, int month)
        {
            return new DateTime(year, month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SetDate(this DateTime value, int year, int month, int day)
        {
            return new DateTime(year, month, day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SetDay(this DateTime value, int day)
        {
            return new DateTime(value.Year, value.Month, day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SetHour(this DateTime originalDate, int hour)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, hour, originalDate.Minute, originalDate.Second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetMillisecond(this DateTime originalDate, int millisecond)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, originalDate.Hour, originalDate.Minute, originalDate.Second, millisecond, originalDate.Kind);
        }
 
        public static DateTime SetMinute(this DateTime originalDate, int minute)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, originalDate.Hour, minute, originalDate.Second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetMonth(this DateTime value, int month)
        {
            return new DateTime(value.Year, month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SetSecond(this DateTime originalDate, int second)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, originalDate.Hour, originalDate.Minute, second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetTime(this DateTime originalDate, int hour)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, hour, originalDate.Minute, originalDate.Second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetTime(this DateTime originalDate, int hour, int minute)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, hour, minute, originalDate.Second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetTime(this DateTime originalDate, int hour, int minute, int second)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, hour, minute, second, originalDate.Millisecond, originalDate.Kind);
        }
 
        public static DateTime SetTime(this DateTime originalDate, int hour, int minute, int second, int millisecond)
        {
            return new DateTime(originalDate.Year, originalDate.Month, originalDate.Day, hour, minute, second, millisecond, originalDate.Kind);
        }
 
        public static DateTime SetYear(this DateTime value, int year)
        {
            return new DateTime(year, value.Month, value.Day, value.Hour, value.Minute, value.Second, value.Millisecond, value.Kind);
        }
 
        public static DateTime SubtractBusinessDays(this DateTime current, int days)
        {
            return current.AddBusinessDays(-days);
        }
 
        public static DateTime ToDateTime(string date, string format = "yyyy-MM-dd")
        {
            DateTime dateTime;
            try
            {
                dateTime = DateTime.ParseExact(date, format, Thread.CurrentThread.CurrentCulture);
            }
            catch (Exception exception)
            {
                throw exception;
            }
            return dateTime;
        }
 
        public static string ToDateTimeStr(this string str, string format = "yyyy-MM-dd")
        {
            string empty;
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }
            try
            {
                DateTime dateTime = DateTime.Parse(str);
                empty = dateTime.ToString(format, DateTimeFormatInfo.InvariantInfo);
            }
            catch
            {
                empty = string.Empty;
            }
            return empty;
        }
 
        public static string ToStringExt(this DateTime date, string Format = "yyyy-MM-dd")
        {
            Format = string.IsNullOrEmpty(Format) ? DefaultFormat : Format;
            return date.ToString(Format, DateTimeFormatInfo.InvariantInfo);
        }
    }

	public enum RoundTo
   {
       Second,
       Minute,
       Hour,
       Day
   }
}