#### [SOLVED] Difference in months between two dates

By Rauf

How to calculate the difference in months between two dates in C#?

Is there is equivalent of VB's `DateDiff()` method in C#. I need to find difference in months between two dates that are years apart. The documentation says that I can use `TimeSpan` like:

``````TimeSpan ts = date1 - date2;
``````

but this gives me data in Days. I don't want to divide this number by 30 because not every month is 30 days and since the two operand values are quite apart from each other, I am afraid dividing by 30 might give me a wrong value.

Any suggestions?

#### @Shahnawaz Alam 2018-06-01 09:46:16

Simple fix. Works 100%

``````        var exactmonth = (date1.Year - date2.Year) * 12 + date1.Month -
date2.Month +  (date1.Day >= date2.Day ? 0 : -1);
Console.WriteLine(exactmonth);
``````

#### @JeffC 2018-06-01 13:47:31

This is an exact copy of DrunkCoder's code from this comment 5 years ago. stackoverflow.com/questions/4638993/…

#### @Simon Mourier 2016-08-19 17:24:27

Here is a simple solution that works at least for me. It's probably not the fastest though because it uses the cool DateTime's AddMonth feature in a loop:

``````public static int GetMonthsDiff(DateTime start, DateTime end)
{
if (start > end)
return GetMonthsDiff(end, start);

int months = 0;
do
{
if (start > end)
return months;

months++;
}
while (true);
}
``````

#### @GreatNate 2014-01-07 18:50:52

There are not a lot of clear answers on this because you are always assuming things.

This solution calculates between two dates the months between assuming you want to save the day of month for comparison, (meaning that the day of the month is considered in the calculation)

Example, if you have a date of 30 Jan 2012, 29 Feb 2012 will not be a month but 01 March 2013 will.

It's been tested pretty thoroughly, probably will clean it up later as we use it, but here:

``````private static int TotalMonthDifference(DateTime dtThis, DateTime dtOther)
{
int intReturn = 0;
bool sameMonth = false;

if (dtOther.Date < dtThis.Date) //used for an error catch in program, returns -1
intReturn--;

int dayOfMonth = dtThis.Day; //captures the month of day for when it adds a month and doesn't have that many days
int daysinMonth = 0; //used to caputre how many days are in the month

while (dtOther.Date > dtThis.Date) //while Other date is still under the other
{
dtThis = dtThis.AddMonths(1); //as we loop, we just keep adding a month for testing
daysinMonth = DateTime.DaysInMonth(dtThis.Year, dtThis.Month); //grabs the days in the current tested month

if (dtThis.Day != dayOfMonth) //Example 30 Jan 2013 will go to 28 Feb when a month is added, so when it goes to march it will be 28th and not 30th
{
if (daysinMonth < dayOfMonth) // uses day in month max if can't set back to day of month
else
}
if (((dtOther.Year == dtThis.Year) && (dtOther.Month == dtThis.Month))) //If the loop puts it in the same month and year
{
if (dtOther.Day >= dayOfMonth) //check to see if it is the same day or later to add one to month
intReturn++;
sameMonth = true; //sets this to cancel out of the normal counting of month
}
if ((!sameMonth)&&(dtOther.Date > dtThis.Date))//so as long as it didn't reach the same month (or if i started in the same month, one month ahead, add a month)
intReturn++;
}
return intReturn; //return month
}
``````

#### @George Mavritsakis 2015-10-02 10:34:52

My understanding of the total months difference between 2 dates has an integral and a fractional part (the date matters).

The integral part is the full months difference.

The fractional part, for me, is the difference of the % of the day (to the full days of month) between the starting and ending months.

``````public static class DateTimeExtensions
{
public static double TotalMonthsDifference(this DateTime from, DateTime to)
{
//Compute full months difference between dates
var fullMonthsDiff = (to.Year - from.Year)*12 + to.Month - from.Month;

//Compute difference between the % of day to full days of each month
var fractionMonthsDiff = ((double)(to.Day-1) / (DateTime.DaysInMonth(to.Year, to.Month)-1)) -
((double)(from.Day-1)/ (DateTime.DaysInMonth(from.Year, from.Month)-1));

return fullMonthsDiff + fractionMonthsDiff;
}
}
``````

With this extension, those are the results:

``````2/29/2000 TotalMonthsDifference 2/28/2001 => 12
2/28/2000 TotalMonthsDifference 2/28/2001 => 12.035714285714286
01/01/2000 TotalMonthsDifference 01/16/2000 => 0.5
01/31/2000 TotalMonthsDifference 01/01/2000 => -1.0
01/31/2000 TotalMonthsDifference 02/29/2000 => 1.0
01/31/2000 TotalMonthsDifference 02/28/2000 => 0.9642857142857143
01/31/2001 TotalMonthsDifference 02/28/2001 => 1.0
``````

#### @jenson-button-event 2014-12-06 14:01:44

I just needed something simple to cater for e.g. employment dates where only the month/year is entered, so wanted distinct years and months worked in. This is what I use, here for usefullness only

``````public static YearsMonths YearMonthDiff(DateTime startDate, DateTime endDate) {
int monthDiff = ((endDate.Year * 12) + endDate.Month) - ((startDate.Year * 12) + startDate.Month) + 1;
int years = (int)Math.Floor((decimal) (monthDiff / 12));
int months = monthDiff % 12;
return new YearsMonths {
TotalMonths = monthDiff,
Years = years,
Months = months
};
}
``````

.NET Fiddle

#### @Saeed Mahmoudi 2015-11-07 11:20:22

The most precise way is this that return difference in months by fraction :

``````private double ReturnDiffereceBetweenTwoDatesInMonths(DateTime startDateTime, DateTime endDateTime)
{
double result = 0;
double days = 0;
DateTime currentDateTime = startDateTime;
{
result ++;

}

if (endDateTime > currentDateTime)
{
days = endDateTime.Subtract(currentDateTime).TotalDays;

}
return result + days/endDateTime.GetMonthDays;
}
``````

#### @reza akhlaghi 2013-09-30 07:28:30

I wrote a function to accomplish this, because the others ways weren't working for me.

``````public string getEndDate (DateTime startDate,decimal monthCount)
{
int y = startDate.Year;
int m = startDate.Month;

for (decimal  i = monthCount; i > 1; i--)
{
m++;
if (m == 12)
{ y++;
m = 1;
}
}
return string.Format("{0}-{1}-{2}", y.ToString(), m.ToString(), startDate.Day.ToString());
}
``````

#### @reza akhlaghi 2014-04-19 05:29:03

oh, sorry @TabbyCool , this code works good in my program! programmers rule says: first code works and then optimization! tanx for ur comment :)

#### @Guillaume86 2012-03-26 14:58:14

If you want the exact number of full months, always positive (2000-01-15, 2000-02-14 returns 0), considering a full month is when you reach the same day the next month (something like the age calculation)

``````public static int GetMonthsBetween(DateTime from, DateTime to)
{
if (from > to) return GetMonthsBetween(to, from);

var monthDiff = Math.Abs((to.Year * 12 + (to.Month - 1)) - (from.Year * 12 + (from.Month - 1)));

if (from.AddMonths(monthDiff) > to || to.Day < from.Day)
{
return monthDiff - 1;
}
else
{
return monthDiff;
}
}
``````

Edit reason: the old code was not correct in some cases like :

``````new { From = new DateTime(1900, 8, 31), To = new DateTime(1901, 8, 30), Result = 11 },

Test cases I used to test the function:

var tests = new[]
{
new { From = new DateTime(1900, 1, 1), To = new DateTime(1900, 1, 1), Result = 0 },
new { From = new DateTime(1900, 1, 1), To = new DateTime(1900, 1, 2), Result = 0 },
new { From = new DateTime(1900, 1, 2), To = new DateTime(1900, 1, 1), Result = 0 },
new { From = new DateTime(1900, 1, 1), To = new DateTime(1900, 2, 1), Result = 1 },
new { From = new DateTime(1900, 2, 1), To = new DateTime(1900, 1, 1), Result = 1 },
new { From = new DateTime(1900, 1, 31), To = new DateTime(1900, 2, 1), Result = 0 },
new { From = new DateTime(1900, 8, 31), To = new DateTime(1900, 9, 30), Result = 0 },
new { From = new DateTime(1900, 8, 31), To = new DateTime(1900, 10, 1), Result = 1 },
new { From = new DateTime(1900, 1, 1), To = new DateTime(1901, 1, 1), Result = 12 },
new { From = new DateTime(1900, 1, 1), To = new DateTime(1911, 1, 1), Result = 132 },
new { From = new DateTime(1900, 8, 31), To = new DateTime(1901, 8, 30), Result = 11 },
};
``````

Just so as to avoid confusion for other people, I think this solution is not correct. Using the test case: `new { From = new DateTime(2015, 12, 31), To = new DateTime(2015, 6, 30), Result = 6 }` the test will fail as the result is 5.

Added a quick gist with the fix I propose here

#### @Guillaume86 2015-12-17 16:48:47

I'm not sure I get it, my function returns 6 as it should: dotnetfiddle.net/MRZNnC

I copied the test case here by hand and It has a mistake. The failing spec should be: `new { From = new DateTime(2015, 12, 31), To = new DateTime(2016, 06, 30), Result = 6 }`. The "bug" lies in the `to.Day < from.Day` code which doesn't take into account that months can end in a different "day of the month". In this case from December 31st 2015, until June 30 2016, 6 complete months will have passed (since June has 30 days) but your code would return 5.

#### @Guillaume86 2015-12-18 15:32:18

It's expected behavior in my opinion, well or it's the behavior I do expect at least. I precised a complete month is when you reach the same day (or the next month like in this case).

I understand, that's why I said that "I think the solution is not correct". I still tried to offer an alternative which results in less confusion. In my mind a month is a calendar subunit with a variable number of days and it makes sense to consider a month complete when it's last day is reached. As another example (taking into account February can have 28/29 days) using your code the difference between 2016, 2, 29 and 2017, 2, 28 would be 11 months which to me is "surprising".

#### @Guillaume86 2015-12-18 17:53:26

Well I guess it's a just a matter of preference. I was also going to mention the leap day case to justify my choice but it's not universal either. There's countries that have set the rule for leap day birthdays in one way and some the other, I side with UK in this case: en.wikipedia.org/wiki/February_29#Legal_status .

#### @Patrice Calvé 2013-10-16 16:08:29

There's 3 cases: same year, previous year and other years.

If the day of the month does not matter...

``````public int GetTotalNumberOfMonths(DateTime start, DateTime end)
{
// work with dates in the right order
if (start > end)
{
var swapper = start;
start = end;
end = swapper;
}

switch (end.Year - start.Year)
{
case 0: // Same year
return end.Month - start.Month;

case 1: // last year
return (12 - start.Month) + end.Month;

default:
return 12 * (3 - (end.Year - start.Year)) + (12 - start.Month) + end.Month;
}
}
``````

#### @Elmer 2013-05-09 17:57:58

This worked for what I needed it for. The day of month didn't matter in my case because it always happens to be the last day of the month.

``````public static int MonthDiff(DateTime d1, DateTime d2){
int retVal = 0;

if (d1.Month<d2.Month)
{
retVal = (d1.Month + 12) - d2.Month;
retVal += ((d1.Year - 1) - d2.Year)*12;
}
else
{
retVal = d1.Month - d2.Month;
retVal += (d1.Year - d2.Year)*12;
}
//// Calculate the number of years represented and multiply by 12
//// Substract the month number from the total
//// Substract the difference of the second month and 12 from the total
//retVal = (d1.Year - d2.Year) * 12;
//retVal = retVal - d1.Month;
//retVal = retVal - (12 - d2.Month);

return retVal;
}
``````

#### @Sukanta 2013-02-12 20:54:57

``````public static int PayableMonthsInDuration(DateTime StartDate, DateTime EndDate)
{
int sy = StartDate.Year; int sm = StartDate.Month; int count = 0;
do
{
count++;if ((sy == EndDate.Year) && (sm >= EndDate.Month)) { break; }
sm++;if (sm == 13) { sm = 1; sy++; }
} while ((EndDate.Year >= sy) || (EndDate.Month >= sm));
return (count);
}
``````

This solution is for Rental/subscription calculation, where difference doesn't means to be subtraction, it's meant to be the span in within those two dates.

#### @Ahmed 2018-02-13 11:43:56

In my case it is required to calculate the complete month from the start date to the day prior to this day in the next month or from start to end of month.

Ex: from 1/1/2018 to 31/1/2018 is a complete month
Ex2: from 5/1/2018 to 4/2/2018 is a complete month

so based on this here is my solution:

``````public static DateTime GetMonthEnd(DateTime StartDate, int MonthsCount = 1)
{
}
public static Tuple<int, int> CalcPeriod(DateTime StartDate, DateTime EndDate)
{
int MonthsCount = 0;
Tuple<int, int> Period;
while (true)
{
if (GetMonthEnd(StartDate) > EndDate)
break;
else
{
MonthsCount += 1;
}
}
int RemainingDays = (EndDate - StartDate).Days + 1;
Period = new Tuple<int, int>(MonthsCount, RemainingDays);
return Period;
}
``````

Usage:

``````Tuple<int, int> Period = CalcPeriod(FromDate, ToDate);
``````

Note: in my case it was required to calculate the remaining days after the complete months so if it's not your case you could ignore the days result or even you could change the method return from tuple to integer.

Assuming the day of the month is irrelevant (i.e. the diff between 2011.1.1 and 2010.12.31 is 1), with date1 > date2 giving a positive value and date2 > date1 a negative value

``````((date1.Year - date2.Year) * 12) + date1.Month - date2.Month
``````

Or, assuming you want an approximate number of 'average months' between the two dates, the following should work for all but very huge date differences.

``````date1.Subtract(date2).Days / (365.25 / 12)
``````

Note, if you were to use the latter solution then your unit tests should state the widest date range which your application is designed to work with and validate the results of the calculation accordingly.

Update (with thanks to Gary)

If using the 'average months' method, a slightly more accurate number to use for the 'average number of days per year' is 365.2425.

#### @Kurru 2011-01-09 12:34:53

Why wouldn't this work for huge date differences?

@Kurru - 365 / 12 is only an approximate measure of the average length of a month in days. It is an inaccurate measure. For small date ranges this inaccuracy can be tolerated but for very huge date ranges this inaccuracy may become significant.

#### @Kurru 2011-01-09 12:44:03

Ahhh forgot about the variable month thing. +1

@Kurru - However, it is also worth pointing out if this 'average month' number is indeed what is being sought after then it is likely that it will be used in a calculation which itself will be an approximation which may mean that the inaccuracy is not significant. We would need to know the intended usage of the result in order to judge this.

#### @Roman Starkov 2011-01-09 13:06:48

Adam, the way I read the question, what is being sought after is your first code snippet. Was about to post it myself.

#### @DrunkCoder 2012-11-21 22:04:08

I think it is necessary to consider Day component. Something like this `(date1.Year - date2.Year) * 12 + date1.Month - date2.Month + (date1.Day >= date2.Day ? 0 : -1)`

@DrunkCoder it depends on the requirements of a given system. In some cases your solution may indeed be the best choice. E.g. it's important to consider what happens when two dates span a 31 day month, a 30 day month, a 28 day February or a 29 day February. If the results of your formula deliver what the system requires then it's clearly the right choice. If not, then something else is required.

#### @Binary Worrier 2013-09-30 07:53:19

To second what Adam said, I spent years writing code for Acturaries. Some calculations were divide by number of days, round up by 30 to get monthly figure. Sometimes counting months assumed every date starts on the first of the month, count whole months accordingly. There is no best method when it comes to calculating dates. Unless you are the customer you're writing code for, push this back up the chain and get it clarified, possibly by you customers accountant.

#### @Gary 2015-09-22 20:39:03

365.2425 is slightly more accurate number of days in a Gregorian Calendar, if that is what you are using. However, by DateTime.MaxValue (January 1, 10000) that's only about 59 days difference. Also, the definition of a year can be much different depending on your perspective en.wikipedia.org/wiki/Year.

Thanks @Gary, I wonder if should update my answer to use 365.2425. It's a cheap change and does indeed improve the accuracy.

Note that the first solution is invalid if one is asking for a date range that lapses over December to January, but doesn't actually complete a year. i.e: Sep 2017 - February 2018 would provide incorrect result

@TjadClark I just tried the first solution for the dates you mention and it gave me the expected answer of 5 months.

Apologies, you are correct!

#### @John A 2017-04-21 15:33:26

This is in response to Kirk Woll's answer. I don't have enough reputation points to reply to a comment yet...

I liked Kirk's solution and was going to shamelessly rip it off and use it in my code, but when I looked through it I realized it's way too complicated. Unnecessary switching and looping, and a public constructor that is pointless to use.

Here's my rewrite:

``````public class DateTimeSpan {
private DateTime _date1;
private DateTime _date2;
private int _years;
private int _months;
private int _days;
private int _hours;
private int _minutes;
private int _seconds;
private int _milliseconds;

public int Years { get { return _years; } }
public int Months { get { return _months; } }
public int Days { get { return _days; } }
public int Hours { get { return _hours; } }
public int Minutes { get { return _minutes; } }
public int Seconds { get { return _seconds; } }
public int Milliseconds { get { return _milliseconds; } }

public DateTimeSpan(DateTime date1, DateTime date2) {
_date1 = (date1 > date2) ? date1 : date2;
_date2 = (date2 < date1) ? date2 : date1;

_years = _date1.Year - _date2.Year;
_months = (_years * 12) + _date1.Month - _date2.Month;
TimeSpan t = (_date2 - _date1);
_days = t.Days;
_hours = t.Hours;
_minutes = t.Minutes;
_seconds = t.Seconds;
_milliseconds = t.Milliseconds;

}

public static DateTimeSpan CompareDates(DateTime date1, DateTime date2) {
return new DateTimeSpan(date1, date2);
}
}
``````

Usage1, pretty much the same:

``````void Main()
{
DateTime compareTo = DateTime.Parse("8/13/2010 8:33:21 AM");
DateTime now = DateTime.Parse("2/9/2012 10:10:11 AM");
var dateSpan = new DateTimeSpan(compareTo, now);
Console.WriteLine("Years: " + dateSpan.Years);
Console.WriteLine("Months: " + dateSpan.Months);
Console.WriteLine("Days: " + dateSpan.Days);
Console.WriteLine("Hours: " + dateSpan.Hours);
Console.WriteLine("Minutes: " + dateSpan.Minutes);
Console.WriteLine("Seconds: " + dateSpan.Seconds);
Console.WriteLine("Milliseconds: " + dateSpan.Milliseconds);
}
``````

Usage2, similar:

``````void Main()
{
DateTime compareTo = DateTime.Parse("8/13/2010 8:33:21 AM");
DateTime now = DateTime.Parse("2/9/2012 10:10:11 AM");
Console.WriteLine("Years: " + DateTimeSpan.CompareDates(compareTo, now).Years);
Console.WriteLine("Months: " + DateTimeSpan.CompareDates(compareTo, now).Months);
Console.WriteLine("Days: " + DateTimeSpan.CompareDates(compareTo, now).Days);
Console.WriteLine("Hours: " + DateTimeSpan.CompareDates(compareTo, now).Hours);
Console.WriteLine("Minutes: " + DateTimeSpan.CompareDates(compareTo, now).Minutes);
Console.WriteLine("Seconds: " + DateTimeSpan.CompareDates(compareTo, now).Seconds);
Console.WriteLine("Milliseconds: " + DateTimeSpan.CompareDates(compareTo, now).Milliseconds);
}
``````

#### @Morgs 2016-08-29 09:37:25

Here is my contribution to get difference in Months that I've found to be accurate:

``````namespace System
{
public static class DateTimeExtensions
{
public static Int32 DiffMonths( this DateTime start, DateTime end )
{
Int32 months = 0;
DateTime tmp = start;

while ( tmp < end )
{
months++;
}

return months;
}
}
}
``````

Usage:

``````Int32 months = DateTime.Now.DiffMonths( DateTime.Now.AddYears( 5 ) );
``````

You can create another method called DiffYears and apply exactly the same logic as above and AddYears instead of AddMonths in the while loop.

#### @Chethaka Wickramarathne 2016-08-10 10:31:13

LINQ Solution,

``````DateTime ToDate = DateTime.Today;

int monthCount = Enumerable.Range(0, 1 + ToDate.Subtract(FromDate).Days)
.ToList<DateTime>()
.GroupBy(z => new { z.Year, z.Month })
.Count();
``````

#### @Brent 2016-04-29 14:48:16

Here's a much more concise solution using VB.Net DateDiff for Year, Month, Day only. You can load the DateDiff library in C# as well.

date1 must be <= date2

VB.NET

``````Dim date1 = Now.AddDays(-2000)
Dim date2 = Now
Dim diffYears = DateDiff(DateInterval.Year, date1, date2) - If(date1.DayOfYear > date2.DayOfYear, 1, 0)
Dim diffMonths = DateDiff(DateInterval.Month, date1, date2) - diffYears * 12 - If(date1.Day > date2.Day, 1, 0)
Dim diffDays = If(date2.Day >= date1.Day, date2.Day - date1.Day, date2.Day + (Date.DaysInMonth(date1.Year, date1.Month) - date1.Day))
``````

C#

``````DateTime date1 = Now.AddDays(-2000);
DateTime date2 = Now;
int diffYears = DateDiff(DateInterval.Year, date1, date2) - date1.DayOfYear > date2.DayOfYear ? 1 : 0;
int diffMonths = DateDiff(DateInterval.Month, date1, date2) - diffYears * 12 - date1.Day > date2.Day ? 1 : 0;
int diffDays = date2.Day >= date1.Day ? date2.Day - date1.Day : date2.Day + (System.DateTime.DaysInMonth(date1.Year, date1.Month) - date1.Day);
``````

#### @Kirk Woll 2012-02-09 18:14:05

Here is a comprehensive solution to return a `DateTimeSpan`, similar to a `TimeSpan`, except that it includes all the date components in addition to the time components.

Usage:

``````void Main()
{
DateTime compareTo = DateTime.Parse("8/13/2010 8:33:21 AM");
DateTime now = DateTime.Parse("2/9/2012 10:10:11 AM");
var dateSpan = DateTimeSpan.CompareDates(compareTo, now);
Console.WriteLine("Years: " + dateSpan.Years);
Console.WriteLine("Months: " + dateSpan.Months);
Console.WriteLine("Days: " + dateSpan.Days);
Console.WriteLine("Hours: " + dateSpan.Hours);
Console.WriteLine("Minutes: " + dateSpan.Minutes);
Console.WriteLine("Seconds: " + dateSpan.Seconds);
Console.WriteLine("Milliseconds: " + dateSpan.Milliseconds);
}
``````

Outputs:

Years: 1
Months: 5
Days: 27
Hours: 1
Minutes: 36
Seconds: 50
Milliseconds: 0

For convenience, I've lumped the logic into the `DateTimeSpan` struct, but you may move the method `CompareDates` wherever you see fit. Also note, it doesn't matter which date comes before the other.

``````public struct DateTimeSpan
{

public DateTimeSpan(int years, int months, int days, int hours, int minutes, int seconds, int milliseconds)
{
this.years = years;
this.months = months;
this.days = days;
this.hours = hours;
this.minutes = minutes;
this.seconds = seconds;
this.milliseconds = milliseconds;
}

public int Years { get { return years; } }
public int Months { get { return months; } }
public int Days { get { return days; } }
public int Hours { get { return hours; } }
public int Minutes { get { return minutes; } }
public int Seconds { get { return seconds; } }
public int Milliseconds { get { return milliseconds; } }

enum Phase { Years, Months, Days, Done }

public static DateTimeSpan CompareDates(DateTime date1, DateTime date2)
{
if (date2 < date1)
{
var sub = date1;
date1 = date2;
date2 = sub;
}

DateTime current = date1;
int years = 0;
int months = 0;
int days = 0;

Phase phase = Phase.Years;
DateTimeSpan span = new DateTimeSpan();
int officialDay = current.Day;

while (phase != Phase.Done)
{
switch (phase)
{
case Phase.Years:
if (current.AddYears(years + 1) > date2)
{
phase = Phase.Months;
}
else
{
years++;
}
break;
case Phase.Months:
if (current.AddMonths(months + 1) > date2)
{
phase = Phase.Days;
if (current.Day < officialDay && officialDay <= DateTime.DaysInMonth(current.Year, current.Month))
}
else
{
months++;
}
break;
case Phase.Days:
if (current.AddDays(days + 1) > date2)
{
var timespan = date2 - current;
span = new DateTimeSpan(years, months, days, timespan.Hours, timespan.Minutes, timespan.Seconds, timespan.Milliseconds);
phase = Phase.Done;
}
else
{
days++;
}
break;
}
}

return span;
}
}
``````

#### @Deeptechtons 2012-11-26 03:36:30

@KirkWoll thanks. But why is that DateTimeSpan returns `34` days for this date time difference actually it is `35` timeanddate.com/date/…

#### @Kirk Woll 2012-11-26 14:09:30

@Deeptechtons, nice catch. There were a couple issues you've brought to my attention, both having to do with the start date is `31` and the date "passes through" months with fewer days. I've inverted the logic (so that it goes from early to later than vice versa) and now accumulates the months without modifying the current date (and thus passing through in-between months with fewer days) Still not entirely sure what the ideal result should be when comparing `10/31/2012` to `11/30/2012`. Right now the result is `1` month.

#### @Deeptechtons 2012-11-27 04:16:48

@KirkWoll thanks for the update, maybe i got few more gotchas let me affirm it after some tests Good Job :)

#### @jwg 2013-08-21 09:51:52

I wrote an answer stackoverflow.com/a/17537472/1737957 to a similar question which tested proposed answers (and found that most of them don't work). This answer is one of the few that does work (according to my test suite). Link to github on my answer.

#### @Enigmativity 2015-06-03 09:29:42

@KirkWoll - This answer doesn't appear to work for edge cases where the from date has a day value higher than the to date's month or where the source date is a leap day. Try `2020-02-29` to `2021-06-29` - it returns "1y 4m 1d", but the value should be "1y 4m 0d", right?

#### @Kirk Woll 2016-04-02 21:45:28

@Enigmativity, thanks for your comments. I've updated my answer by handling this scenario in the `Phase.Months` section. Seems to work for me.

#### @Gone Coding 2016-04-19 09:40:15

Very cool, but please note this algorithm has some edge-case issues. If you happen to use `DateTime.MinValue` or `DateTime.MaxValue`in date values this will fall over. e.g. `System.ArgumentOutOfRangeException': "The added or subtracted value results in an un-representable DateTime."`

#### @Waleed A.K. 2015-10-22 18:04:13

you can use the following extension: Code

``````public static class Ext
{
#region Public Methods

public static int GetAge(this DateTime @this)
{
var today = DateTime.Today;
return ((((today.Year - @this.Year) * 100) + (today.Month - @this.Month)) * 100 + today.Day - @this.Day) / 10000;
}

public static int DiffMonths(this DateTime @from, DateTime @to)
{
return (((((@to.Year - @from.Year) * 12) + (@to.Month - @from.Month)) * 100 + @to.Day - @from.Day) / 100);
}

public static int DiffYears(this DateTime @from, DateTime @to)
{
return ((((@to.Year - @from.Year) * 100) + (@to.Month - @from.Month)) * 100 + @to.Day - @from.Day) / 10000;
}

#endregion Public Methods
}
``````

Implementation !

``````int Age;
int years;
int Months;
var d1 = new DateTime(2000, 10, 22);
var d2 = new DateTime(2003, 10, 20);
//Age
Age = d1.GetAge();
Age = d2.GetAge();
//positive
years = d1.DiffYears(d2);
Months = d1.DiffMonths(d2);
//negative
years = d2.DiffYears(d1);
Months = d2.DiffMonths(d1);
//Or
Months = Ext.DiffMonths(d1, d2);
years = Ext.DiffYears(d1, d2);
``````

#### @Edward Brey 2015-09-14 13:11:47

Use Noda Time:

``````LocalDate start = new LocalDate(2013, 1, 5);
LocalDate end = new LocalDate(2014, 6, 1);
Period period = Period.Between(start, end, PeriodUnits.Months);
Console.WriteLine(period.Months); // 16
``````

(example source)

#### @Bhavesh Patel 2015-06-12 07:22:33

``````int nMonths = 0;
if (FDate.ToDateTime().Year == TDate.ToDateTime().Year)
nMonths = TDate.ToDateTime().Month - FDate.ToDateTime().Month;
else
nMonths = (12 - FDate.Month) + TDate.Month;
``````

#### @Konstantin Chernov 2015-01-21 11:57:45

Here's how we approach this:

``````public static int MonthDiff(DateTime date1, DateTime date2)
{
if (date1.Month < date2.Month)
{
return (date2.Year - date1.Year) * 12 + date2.Month - date1.Month;
}
else
{
return (date2.Year - date1.Year - 1) * 12 + date2.Month - date1.Month + 12;
}
}
``````

#### @Chirag 2014-04-05 07:01:54

To get difference in months (both start and end inclusive), irrespective of dates:

``````DateTime start = new DateTime(2013, 1, 1);
DateTime end = new DateTime(2014, 2, 1);
var diffMonths = (end.Month + end.Year * 12) - (start.Month + start.Year * 12);
``````

#### @paul 2014-12-18 06:35:36

Imagine `start` and `end` are identical. Then you get a result of 1. How is that right? Why do you add 1 to the result? Who is up-voting this answer :-/ ?

#### @Chirag 2014-12-18 11:29:26

For identical dates, it will give output as 1. Basically, it will count all the months inclusive start and end months.

#### @paul 2014-12-18 11:57:43

doesn't sound like the difference between two items to me. What is the difference between 2 and 2? Is it really 1? I would suggest the difference is 0.

#### @user687474 2014-04-05 08:09:29

You can use the DateDiff class of the Time Period Library for .NET:

``````// ----------------------------------------------------------------------
public void DateDiffSample()
{
DateTime date1 = new DateTime( 2009, 11, 8, 7, 13, 59 );
DateTime date2 = new DateTime( 2011, 3, 20, 19, 55, 28 );
DateDiff dateDiff = new DateDiff( date1, date2 );

// differences
Console.WriteLine( "DateDiff.Months: {0}", dateDiff.Months );
// > DateDiff.Months: 16

// elapsed
Console.WriteLine( "DateDiff.ElapsedMonths: {0}", dateDiff.ElapsedMonths );
// > DateDiff.ElapsedMonths: 4

// description
Console.WriteLine( "DateDiff.GetDescription(6): {0}", dateDiff.GetDescription( 6 ) );
// > DateDiff.GetDescription(6): 1 Year 4 Months 12 Days 12 Hours 41 Mins 29 Secs
} // DateDiffSample
``````

#### @Paul 2014-01-23 17:22:03

``````  var dt1 = (DateTime.Now.Year * 12) + DateTime.Now.Month;
Console.WriteLine(dt1);
Console.WriteLine(dt2);
Console.WriteLine((dt1 - dt2));
``````

#### @Ivan 2013-12-06 13:37:52

Expanded Kirks struct with ToString(format) and Duration(long ms)

`````` public struct DateTimeSpan
{

public DateTimeSpan(int years, int months, int days, int hours, int minutes, int seconds, int milliseconds)
{
this.years = years;
this.months = months;
this.days = days;
this.hours = hours;
this.minutes = minutes;
this.seconds = seconds;
this.milliseconds = milliseconds;
}

public int Years { get { return years; } }
public int Months { get { return months; } }
public int Days { get { return days; } }
public int Hours { get { return hours; } }
public int Minutes { get { return minutes; } }
public int Seconds { get { return seconds; } }
public int Milliseconds { get { return milliseconds; } }

enum Phase { Years, Months, Days, Done }

public string ToString(string format)
{
format = format.Replace("YYYY", Years.ToString());
format = format.Replace("MM", Months.ToString());
format = format.Replace("DD", Days.ToString());
format = format.Replace("hh", Hours.ToString());
format = format.Replace("mm", Minutes.ToString());
format = format.Replace("ss", Seconds.ToString());
format = format.Replace("ms", Milliseconds.ToString());
return format;
}

public static DateTimeSpan Duration(long ms)
{
DateTime dt = new DateTime();
}

public static DateTimeSpan CompareDates(DateTime date1, DateTime date2)
{
if (date2 < date1)
{
var sub = date1;
date1 = date2;
date2 = sub;
}

DateTime current = date1;
int years = 0;
int months = 0;
int days = 0;

Phase phase = Phase.Years;
DateTimeSpan span = new DateTimeSpan();

while (phase != Phase.Done)
{
switch (phase)
{
case Phase.Years:
if (current.AddYears(years + 1) > date2)
{
phase = Phase.Months;
}
else
{
years++;
}
break;
case Phase.Months:
if (current.AddMonths(months + 1) > date2)
{
phase = Phase.Days;
}
else
{
months++;
}
break;
case Phase.Days:
if (current.AddDays(days + 1) > date2)
{
var timespan = date2 - current;
span = new DateTimeSpan(years, months, days, timespan.Hours, timespan.Minutes, timespan.Seconds, timespan.Milliseconds);
phase = Phase.Done;
}
else
{
days++;
}
break;
}
}

return span;
}
}
``````

#### @Firnas 2012-12-27 10:43:41

You can have a function something like this.

For Example, from 2012/12/27 to 2012/12/29 becomes 3 days. Likewise, from 2012/12/15 to 2013/01/15 becomes 2 months, because up to 2013/01/14 it's 1 month. from 15th it's 2nd month started.

You can remove the "=" in the second if condition, if you do not want to include both days in the calculation. i.e, from 2012/12/15 to 2013/01/15 is 1 month.

``````public int GetMonths(DateTime startDate, DateTime endDate)
{
if (startDate > endDate)
{
throw new Exception("Start Date is greater than the End Date");
}

int months = ((endDate.Year * 12) + endDate.Month) - ((startDate.Year * 12) + startDate.Month);

if (endDate.Day >= startDate.Day)
{
months++;
}

return months;
}
``````

#### @Tom 2012-06-11 17:27:24

To be able to calculate the difference between 2 dates in months is a perfectly logical thing to do, and is needed in many business applications. The several coders here who have provided comments such as - what's the difference in months between "May 1,2010" and "June 16,2010, what's the difference in months between 31 December 2010 and 1 Jan 2011? -- have failed to understand the very basics of business applications.

Here is the answer to the above 2 comments - The number of months between 1-may-2010 and 16-jun-2010 is 1 month, the number of months between 31-dec-2010 and 1-jan-2011 is 0. It would be very foolish to calculate them as 1.5 months and 1 second, as the coders above have suggested.

People who have worked on credit card, mortgage processing, tax processing, rent processing, monthly interest calculations and a vast variety of other business solutions would agree.

Problem is that such a function is not included in C# or VB.NET for that matter. Datediff only takes into account years or the month component, so is actually useless.

Here are some real-life examples of where you need to and correctly can calculate months:

You lived in a short-term rental from 18-feb to 23-aug. How many months did you stay there? The answer is a simple - 6 months

You have a bank acount where interest is calculated and paid at the end of every month. You deposit money on 10-jun and take it out 29-oct (same year). How many months do you get interest for? Very simple answer- 4 months (again the extra days do not matter)

In business applications, most of the time, when you need to calculate months, it is because you need to know 'full' months based on how humans calculate time; not based on some abstract/irrelevant thoughts.

#### @quetzalcoatl 2013-04-25 15:18:35

This is one of the reasons why accounting is not mathematics. In accounting the result depends on the way you calculate it.. I know your points and I know the "common business view" on this, but this explanation is plainly wrong. Between 2012.11.30 and 2012.12.01 there is either 0, or 1/30, or 1/31, or 1 or 2 months, depending on what did you ask for. Were the dates exlusive or inclusive? Did you ask for number of months crossed, touched, or passed? Did you want round-up, round-down, or exact?

#### @quetzalcoatl 2013-04-25 15:25:18

Now explain it to a business guy or an accountant and they'll give you a puzzled look. It's always "so obvious to them that they of course meant X and Y and Z, how could you thought differently?" Now get several business-people and try to get them to agree on the topic. Accountants are more likely to agree, because at some point they will use maths to check with what options they might accidentially sum up the same period twice, etc. Even your examples of calculations are disputable and region-dependent, or plainly invalid as they assume extra business rules like ignoring extra days.

#### @Jesse Webb 2014-03-28 22:32:15

-1 You are assuming that all software is a "business application". The purpose of the code in question is not mentioned. You also assume all "business applications" have the same rules, which is definitely not true.

#### @Wayne 2012-04-24 15:24:21

This is from my own library, will return the difference of months between two dates.

``````public static int MonthDiff(DateTime d1, DateTime d2)
{
int retVal = 0;

// Calculate the number of years represented and multiply by 12
// Substract the month number from the total
// Substract the difference of the second month and 12 from the total
retVal = (d1.Year - d2.Year) * 12;
retVal = retVal - d1.Month;
retVal = retVal - (12 - d2.Month);

return retVal;
}
``````

#### @Dave Cousineau 2014-08-17 02:31:13

Does this work? I keep getting 11 on paper for `Jan-31-2014` and `Dec-31-2013`

#### @Mongus Pong 2011-09-20 16:36:26

You could do

``````if ( date1.AddMonths(x) > date2 )
``````

#### @lucky.expert 2018-02-26 15:05:44

This is so simple and works perfect for me. I was pleasantly surprised to see it works as intended when calculating a date from the end of 1 month to a date at the end of the next month that has less days. For example.. 1-31-2018 + 1 month = Feb 28 218

#### @barnacle.m 2018-05-22 12:39:02

This is one of the better solutions.

### [SOLVED] How do I get the current date in JavaScript?

• 2009-10-07 11:39:02
• Suresh
• 1988815 View
• 1760 Score
• Tags:   javascript date

### [SOLVED] Why is subtracting these two times (in 1927) giving a strange result?

• 2011-07-27 08:15:58
• Freewind
• 565224 View
• 6142 Score
• Tags:   java date timezone

### [SOLVED] Calculate difference between two dates (number of days)?

• 2009-10-22 13:47:15
• leora
• 898813 View
• 857 Score
• Tags:   c# date

### [SOLVED] Number of days between two dates in Joda-Time

• 2010-09-27 10:21:30
• pvgoddijn
• 172712 View
• 289 Score
• Tags:   java date jodatime

### [SOLVED] How to get difference between two dates in Year/Month/Week/Day?

• 2009-07-05 12:11:55
• Ahmed
• 99696 View
• 44 Score