Austinslik's Blog

Get Datetime difference wpf-c#

Posted by austinslik on March 7, 2010

Here is a straight forward way to get the difference between a given begin date and end date (Hour(s), Day(s), Week(s) ISO/US, Month(s), Quarter(s) and Year(s)) in Wpf c#. This can be done in so many ways to accomplish a certain task. This was needed for Reporting GUI. If you have a similar kind of task this might help. I have to say it’s not that obvious on how to do this in c# but with this I hope someone don’t have to suffer just to get e.g. number of weeks(ISO or US) between a given two date(month/year). The method GetDateTimeDiff(…) with parameter of two datetime 1. beginYear, beginQuater, beginMonth, beginWeek, beginDay, beginHour 2. endYear, endQuater, endMonth, endWeek, endDay, endHour. Zero any parameter you don’t need e.g. you want to get weeks between a given week number of a year like 50th week of 2009 to 1st week of 2010 = 5 weeks (important: begin… > end… always!). GetDateTimeDiff () will look like this in the constructor GetDateTimeDiff(“WeeksIso”, 2010, 0, 0, 1, 0, 00, 2009, 0, 0, 50, 0, 00).

Note: Year hast to be set always and begin year will always be the current year.

The GetDateTimeDiff() is defined like

        public string GetDateTimeDiff(
            string level,
            int beginYear,
            int beginQuarter,
            int beginMonth,
            int beginWeek,
            int beginDay,
            int beginHour,
            int endYear,
            int endQuarter,
            int endMonth,
            int endWeek,
            int endDay,
            int endHour
            )
        {
            if (level != string.Empty)
            {
                const int range = 100;
                const int YearRange = 10;
                int countHours = 0;
                int countDays = 0;
                int countWeeks = 0;
                int countMonth = 0;
                int countYear = 0;
                switch (level)
                {
                    #region Hour
                    case "Hours":
                        {
                            if (beginHour < 24 && endHour < 24)
                            {
                                DateTime _beginDate = new DateTime(beginYear, beginMonth, beginDay, beginHour, 0, 0);
                                DateTime _endDate = new DateTime(endYear, endMonth, endDay, endHour, 0, 0);
                                if (_beginDate.Hour > DateTime.Now.Hour && _beginDate > DateTime.Now)
                                    return "Begin Day and Hour must be set to current ";
                                if (_endDate == _beginDate)
                                    return "This Hour";
                                if (_endDate == _beginDate)
                                    return "Last Hour";
                                if (_endDate < _beginDate)
                                {
                                    countDays = GetHoursBetweenDates(_beginDate, _endDate);
                                    if (countHours > range)
                                        return "You can only review last 100 Hours";
                                    return GetHoursBetweenDates(_beginDate, _endDate) + " Hours Ago";
                                }
                            }
                            break;
                        }
                    #endregion

                    #region Days
                    case "Days":
                        {
                            DateTime _beginDate = new DateTime(beginYear, beginMonth, beginDay);
                            DateTime _endDate = new DateTime(endYear, endMonth, endDay);

                            if (_endDate > _beginDate)
                                return "Begin Day must be set to current day";
                            if (_endDate == _beginDate)
                                return "Today";
                            if (_endDate.Day == _beginDate.Day - 1)
                                return "Yesterday";
                            if (_endDate < _beginDate)
                            {
                                countDays = GetDaysBetweenDates(_beginDate, _endDate);
                                if (countDays > range)
                                    return "You can only review last 100 days";
                                return countDays + " Days Ago";
                            }
                            break;
                        }
                    #endregion

                    #region WeeksIso
                    case "WeeksIso":
                        {
                            if ( beginWeek <= WeeksInYearIso(beginYear) && endWeek <= WeeksInYearIso(endYear))
                            {
                                countWeeks = GetIsoWeekNumber(GetIsoWeekStartDate(beginYear, beginWeek), GetIsoWeekStartDate(endYear, endWeek));
                                if (countWeeks <= range)
                                    return countWeeks + " Weeks Ago";
                                return "You can only review Last 100 Weeks";
                            }
                            break;
                        }
                    #endregion

                    #region WeeksUs
                    case "WeeksUs":
                        {
                            if (beginWeek <= WeeksInYearUs(beginYear) && endWeek <= WeeksInYearUs(endYear))
                            {
                                if (beginYear < endYear)
                                    return "Begin Year cannot be greater that End Year";

                                if (beginYear == endYear)
                                {
                                    countWeeks = GetUsWeekNumber(GetUsWeekStartDate(beginYear, beginWeek)) - 
                                        GetUsWeekNumber(GetUsWeekStartDate(beginYear, endWeek));

                                    if (countWeeks <= range)
                                        return countWeeks + " Weeks Ago";
                                }
                                if (endYear < beginYear)
                                {
                                    countWeeks = GetUsWeekNumber(GetUsWeekStartDate(beginYear, beginWeek)) +
                                            WeeksInYearUs(endYear) - GetUsWeekNumber(GetUsWeekStartDate(endYear, endWeek));

                                    if (countWeeks <= range)
                                        return countWeeks + " Weeks Ago";
                                    return "You can only review Last 100 Weeks";
                                }
                            }
                            break;
                        }
                    #endregion

                    #region Months
                    case "Months":
                        {
                            DateTime _beginDate = new DateTime(beginYear, beginMonth, 1);
                            DateTime _endDate = new DateTime(endYear, endMonth, 1);

                            if (_beginDate > _endDate)
                            {
                                IEnumerator enumerator = GetMonth(_beginDate, _endDate).GetEnumerator();
                                while (enumerator.MoveNext())
                                {
                                    countMonth++;

                                    if (countMonth >= range)
                                        return string.Format("You can only review Last 100 Months\n {0} Months Ago", countMonth);
                                    if (_beginDate.Month - 1 == _endDate.Month &&
                                        _beginDate.Year == _endDate.Year)
                                        return "Last Month";
                                }
                                return countMonth + " Months Ago";
                            }

                            break;
                        }
                    #endregion

                    #region Quarter
                    case "Quarter":
                        {
                            if (beginQuarter == (int)GetQuarter(DateTime.Now.Month, DateTime.Now.Year) && beginYear == DateTime.Now.Year)
                            {
                                if (beginYear == endYear)
                                {
                                    int quarterCount = beginQuarter - endQuarter;

                                    return quarterCount + " Quarters Ago";
                                }
                                if (endYear < beginYear)
                                {
                                    int quarterCount = (4 - endQuarter) + beginQuarter;

                                    if (quarterCount > 4)
                                        return "You can only review upto last 4 Quarters";
                                    return quarterCount + " Quarters Ago";
                                }
                            }
                            return "Begin Quarter and Begin Year must be current";
                        }
                    #endregion

                    #region year
                    case "Years":

                        DateTime _beginYear = new DateTime(beginYear, 1, 1);
                        DateTime _endYear = new DateTime(endYear,1,1);
                        if (_endYear.Year > _beginYear.Year)
                            return "End Year must less than Begin year";
                        if (_beginYear.Year != DateTime.Now.Year)
                            return "Begin Year must be current year";
                        if (_endYear.Year < _beginYear.Year)
                        {
                            IEnumerator enumerator = GetYear(_beginYear, _endYear).GetEnumerator();
                            while (enumerator.MoveNext())
                            {
                                countYear++;
                                if (countYear >= YearRange)
                                    return "You can only review Last 5 years";
                            }
                            return countYear + " Years Ago";
                        }
                        if (_beginYear.Year == endYear)
                            return "This Year";
                        if (_beginYear.Year -1 == endYear)
                            return "Last Year";
                        break;
                    #endregion

                    default:
                        break;
                }
            }
            return string.Empty;
        }

Get days between dates
 
        private int GetDaysBetweenDates(
            DateTime beginDate,
            DateTime endDate)
        {
            return beginDate.Subtract(endDate).Days;
        }

        #endregion

Get hours between dates
 
        private int GetHoursBetweenDates(
            DateTime beginDate,
            DateTime endDate)
        {
            TimeSpan timeSpan = beginDate.Subtract(endDate);
            return (int)timeSpan.TotalHours;
        }

Get ISO week start date
 
        static DateTime GetIsoWeekStartDate(int year,int weekNumber)
        {
            DateTime januaryFirst = new DateTime(year, 1, 1);

            int daysOffset = DayOfWeek.Monday - januaryFirst.DayOfWeek;
            DateTime firstMonday = januaryFirst.AddDays(daysOffset);

            GregorianCalendar calendar = new GregorianCalendar(GregorianCalendarTypes.Localized);
            int firstWeek = calendar.GetWeekOfYear(januaryFirst, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

            if (firstWeek <= 1)
                weekNumber -= 1;

            DateTime weekStartDate = firstMonday.AddDays(weekNumber * 7);

            return weekStartDate;
        }

Get ISO weeks number
        public static int GetIsoWeekNumber(
            DateTime beginDate,
            DateTime endDate)
        {
            int Days = 0;
            int WeekCount = 0;

            TimeSpan Span = beginDate.Subtract(endDate);

            if (Span.Days <= 7)
            {
                if (endDate.DayOfWeek > beginDate.DayOfWeek)
                    return 1;
                return 0;
            }
            int x = (int)endDate.DayOfWeek;
            Days = Span.Days - (4 + (int)endDate.DayOfWeek);
            WeekCount = (Days / 7) + 2;

            return WeekCount;
        }

Get ISO weeks in year
        public static int WeeksInYearIso(
            int year)
        {
            GregorianCalendar cal =
                new GregorianCalendar(GregorianCalendarTypes.Localized);
            return cal.GetWeekOfYear(
                new DateTime(year, 12, 28), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
        }

Get US week start date
        static DateTime GetUsWeekStartDate(
            int year,
            int weekNumber)
        {
            DateTime januaryFirst = new DateTime(year, 1, 1);

            if (weekNumber < = 1)
                return januaryFirst;

            int daysOffset = DayOfWeek.Sunday - januaryFirst.DayOfWeek;
            DateTime Sunday = januaryFirst.AddDays(daysOffset);

            GregorianCalendar calendar = new GregorianCalendar(GregorianCalendarTypes.Localized);
            int week = calendar.GetWeekOfYear(januaryFirst, CalendarWeekRule.FirstDay, DayOfWeek.Sunday);

            if (week <= 1)
                weekNumber -= 1;

            DateTime weekStartDate = Sunday.AddDays(weekNumber * 7);

            return weekStartDate;
        }

Get US weeks number
        public static int GetUsWeekNumber(
            DateTime dateTime)
        {
            int weekNumber = 0;
            CultureInfo culture;

            culture = CultureInfo.CurrentCulture;
            weekNumber =
                culture.Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday);

            return weekNumber;
        } 

Get US weeks in year
 
        public static int WeeksInYearUs(
            int year)
        {
            GregorianCalendar cal =
                new GregorianCalendar(GregorianCalendarTypes.Localized);
            return cal.GetWeekOfYear(
                new DateTime(year, 12, 31), CalendarWeekRule.FirstDay, DayOfWeek.Sunday);
        }

Get month(s)
 
        public IEnumerable<DateTime> GetMonth(
                DateTime beginMonth,
                DateTime endMonth)
        {
            for (DateTime month = endMonth; month < beginMonth; )
            {
                yield return month;
                month = month.AddMonths(1);
            }
        }

Get quarter(s)
 
        public static Quarter GetQuarter(int month,int year)
        {
            if (month <= (int)Month.March)
                return Quarter.First;
            else if ((month >= (int)Month.April) && (month <= (int)Month.June))
                return Quarter.Second;
            else if ((month >= (int)Month.July) && (month <= (int)Month.September))
                return Quarter.Third;
            else
                return Quarter.Fourth;
        }

Get year(s)
 
        public IEnumerable<DateTime> GetYear(
                DateTime beginYear,
                DateTime endYear)
        {
            for (DateTime yearDiff = endYear; yearDiff < beginYear; yearDiff = yearDiff.AddYears(1))
            {
                yield return yearDiff;
            }
        }

Month and Quarter are enums.
        
 public enum Month
        {
            January = 1,
            February = 2,
            March = 3,
            April = 4,
            May = 5,
            June = 6,
            July = 7,
            August = 8,
            September = 9,
            October = 10,
            November = 11,
            December = 12
        }
        public enum Quarter
        {
            First = 1,
            Second = 2,
            Third = 3,
            Fourth = 4
        }

In the constructor
            _txtBlock.Text += (GetDateTimeDiff("Hours", 2010, 0, 1, 0, 21, 00, 2010, 0, 1, 0, 20, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("Days", 2010, 0, 1, 0, 21, 00, 2010, 0, 1, 0, 01, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("WeeksIso", 2010, 0, 0, 1, 0, 00, 2009, 0, 0, 50, 0, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("WeeksUs", 2010, 0, 0, 1, 0, 00, 2009, 0, 0, 50, 0, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("Months", 2010, 0, 09, 0, 0, 00, 2007, 0, 08, 0, 0, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("Quarter", 2010, 1, 0, 0, 0, 00, 2008, 3, 0, 0, 0, 00) + "\n\n");
            _txtBlock.Text += (GetDateTimeDiff("Years", 2010, 0, 0, 0, 0, 00, 2005, 0, 0, 0, 0, 00) + "\n");

Download the source code here
Tested it here

Advertisement

One Response to “Get Datetime difference wpf-c#”

  1. Raja Ram said

    this helps

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Connecting to %s

 
Follow

Get every new post delivered to your Inbox.