计算两个日期之间的月份差异

Question

在 C#/.NET 中，TimeSpan 有 TotalDays、TotalMinutes 等，但我无法找出总月差的公式。每月不同的日子和闰年总是让我感到困惑。如何获取TotalMonths？

编辑抱歉没有说得更清楚：我知道我实际上无法从TimeSpan得到这个，但我想使用TotalDays和TotalMinutes 将是一个很好的例子来表达我正在寻找的内容......除了我试图获取总月数。

示例：2009 年 12 月 25 日 - 2009 年 10 月 6 日 = 总共 2 个月。 10 月 6 日至 11 月 5 日等于 0 个月。 11月6日，1个月。 2个月后12月6日

Answer 1

以下是我对获取月份差异所做的贡献，我发现它是准确的：

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++;
                 tmp = tmp.AddMonths( 1 );
             }

             return months;
        }
    }
}

用法：

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

您可以创建另一个名为 DiffYears 的方法，并应用与上面完全相同的逻辑，并在 while 循环中使用 AddYears 而不是 AddMonths。

Answer 2

游戏已经晚了，但我想这可能对某人有帮助。大多数人倾向于按日期来衡量每月的情况，排除了月份有不同变化的事实。利用这一思想框架，我创建了一个单行表来为我们比较日期。使用以下过程。

1. 比较年份时任何超过 1 的年数都将乘以 12，在任何情况下都不会小于 1 整年。
2. 如果结束年份更大，我们需要评估当前日期是否大于或等于前一天
   2A。如果结束日期大于或等于当前月份，然后加上 12 个月减去起始月份的月份
   2B。如果结束日期小于开始日期，我们执行与上面相同的操作，只是在减去之前在开始月份中加 1

3. 如果结束年份不大于我们执行与 2A/2B 相同的操作，但不添加12 个月，因为我们不需要全年评估。

    DateTime date = new DateTime(2003, 11, 25);
       今天的日期时间 = new DateTime(2004, 12, 26);
       var time = (today.Year - date.Year > 1 ? (today.Year - date.Year - 1) * 12 : 0) + (today.Year > date.Year ? (today.Day >= date) .日 ? 今天.月 + 12 - 日期.月 : 今天.月 + 12 - (日期.月 + 1)) : (今天.日 >= 日期.日 ? 今天.月 - 日期.月 : 今天.月- (日期.月份 + 1)));
   

Answer 3

我对这个答案的看法也使用了扩展方法，但它可以返回正值或负值结果。

public static int MonthsBefore(this DateTime dt1, DateTime dt2)
{
    (DateTime early, DateTime late, bool dt2After) = dt2 > dt1 ? (dt1,dt2,true) : (dt2,dt1,false);
    DateTime tmp; // Save the result so we don't repeat work
    int months = 1;
    while ((tmp = early.AddMonths(1)) <= late)
    {
        early = tmp;
        months++;
    }
    return (months-1)*(dt2After ? 1 : -1);
}

一些测试：

// Just under 1 month's diff
Assert.AreEqual(0, new DateTime(2014, 1, 1).MonthsBefore(new DateTime(2014, 1, 31)));
// Just over 1 month's diff
Assert.AreEqual(1, new DateTime(2014, 1, 1).MonthsBefore(new DateTime(2014, 2, 2)));    
// Past date returns NEGATIVE
Assert.AreEqual(-6, new DateTime(2012, 1, 1).MonthsBefore(new DateTime(2011, 6, 10)));

Answer 4

结合上面的两个答案，另一种扩展方法是：

public static int ElapsedMonths(this DateTime date1, DateTime date2)
{
    DateTime earlierDate = (date1 > date2) ? date2 : date1;
    DateTime laterDate = (date1 > date2) ? date1 : date2;
    var eMonths = (laterDate.Month - earlierDate.Month) + 12 * (laterDate.Year - earlierDate.Year) - 
                                            ((earlierDate.Day > laterDate.Day) ? 1 : 0);
    return eMonths;
}

感谢@AdamRobinson和@MarkWhittaker

Answer 5

我们是这样做的：

int DifferenceInMonth(DateTime startDate, DateTime endDate) {
    long ToTicks(DateTime date) => new DateTimeOffset(date).Ticks;
    var daysPerMonth = 30.4;
    return (int)Math.Round((ToTicks(endDate) - ToTicks(startDate)) / TimeSpan.TicksPerDay / daysPerMonth);
}

Answer 6

接受的答案非常不正确：

对于这些日期：ldate = 2020-08-30 和 rdate = 2020-08-01，我们有一个月，但接受的答案返回 0。

对于这些日期：ldate = 2020-08-30并且 rdate = 2020-10-01，我们有三个月，但接受的答案返回 -2。

这是计算两个日期之间的月份数的正确方法（也许不是唯一的方法，但正确）：

• 您不必检查哪个日期比其他日期晚。

• 从每月的第一天到最后一天的间隔算作一个月。

   public static int GetMontsBetween(DateTime date1, DateTime date2)
    {
        int 月份计数 = 0;
        int 方向 = date1 <日期2？ 1：-1；
        date2 = date2.AddDays(方向);
  
        while (date1.Year!= date2.Year || date1.Month != date2.Month)
        {
            date1 = date1.AddMonths(方向);
            月数++；
        }
  
        返回月份计数；
    } 
  

Answer 7

您无法从 TimeSpan 中获取该值，因为“月”是可变的计量单位。你必须自己计算它，并且必须弄清楚你希望它到底如何工作。

例如，2009 年 7 月 5 日 和 2009 年 8 月 4 日 这样的日期应该产生一个月还是零个月的差异？如果您说它应该产生一个，那么 2009 年 7 月 31 日 和 2009 年 8 月 1 日 又如何呢？ 那是一个月吗？这只是日期的Month值的差异，还是与实际的时间跨度更相关？确定所有这些规则的逻辑并不简单，因此您必须确定自己的规则并实现适当的算法。

如果您想要的只是月份的差异 - 完全忽略日期值 - 那么您可以使用这个：

public static int MonthDifference(this DateTime lValue, DateTime rValue)
{
    return (lValue.Month - rValue.Month) + 12 * (lValue.Year - rValue.Year);
}

请注意，这会返回相对差异，这意味着如果 rValue 大于 lValue，则返回值为负数。如果你想要绝对差异，你可以使用这个：

public static int MonthDifference(this DateTime lValue, DateTime rValue)
{
    return Math.Abs((lValue.Month - rValue.Month) + 12 * (lValue.Year - rValue.Year));
}

Answer 8

（我意识到这是一个老问题，但是...）

在纯 .NET 中执行此操作相对痛苦。我推荐我自己的 Noda Time 库，它是专门为这样的事情而设计的：（

LocalDate start = new LocalDate(2009, 10, 6);
LocalDate end = new LocalDate(2009, 12, 25);
Period period = Period.Between(start, end);
int months = period.Months;

还有其他选项，例如，如果您只想要一个计数月份甚至跨年，您可以使用Period period = period.Between(start, end, periodUnits.Months);)

Answer 9

也许您不想了解月份分数；这段代码怎么样？

public static class DateTimeExtensions
{
    public static int TotalMonths(this DateTime start, DateTime end)
    {
        return (start.Year * 12 + start.Month) - (end.Year * 12 + end.Month);
    }
}

//  Console.WriteLine(
//     DateTime.Now.TotalMonths(
//         DateTime.Now.AddMonths(-1))); // prints "1"

Answer 10

我在 DateTime 和 DateTimeOffset 上编写了一个非常简单的扩展方法来执行此操作。我希望它的工作方式与 TotalMonths 属性完全相同>TimeSpan 可以工作：即返回两个日期之间完整月份的计数，忽略任何部分月份。因为它基于 DateTime .AddMonths() 它尊重不同的月份长度并返回人类所理解的月份。

（不幸的是，您无法将其实现为 TimeSpan 的扩展方法，因为这不会保留实际使用日期的知识，而且对于几个月来说它们很重要。）

代码和测试都是 可在 GitHub 上获取。代码非常简单：

public static int GetTotalMonthsFrom(this DateTime dt1, DateTime dt2)
{
    DateTime earlyDate = (dt1 > dt2) ? dt2.Date : dt1.Date;
    DateTime lateDate = (dt1 > dt2) ? dt1.Date : dt2.Date;

    // Start with 1 month's difference and keep incrementing
    // until we overshoot the late date
    int monthsDiff = 1;
    while (earlyDate.AddMonths(monthsDiff) <= lateDate)
    {
        monthsDiff++;
    }

    return monthsDiff - 1;
}

并且它通过了所有这些单元测试用例：

// Simple comparison
Assert.AreEqual(1, new DateTime(2014, 1, 1).GetTotalMonthsFrom(new DateTime(2014, 2, 1)));
// Just under 1 month's diff
Assert.AreEqual(0, new DateTime(2014, 1, 1).GetTotalMonthsFrom(new DateTime(2014, 1, 31)));
// Just over 1 month's diff
Assert.AreEqual(1, new DateTime(2014, 1, 1).GetTotalMonthsFrom(new DateTime(2014, 2, 2)));
// 31 Jan to 28 Feb
Assert.AreEqual(1, new DateTime(2014, 1, 31).GetTotalMonthsFrom(new DateTime(2014, 2, 28)));
// Leap year 29 Feb to 29 Mar
Assert.AreEqual(1, new DateTime(2012, 2, 29).GetTotalMonthsFrom(new DateTime(2012, 3, 29)));
// Whole year minus a day
Assert.AreEqual(11, new DateTime(2012, 1, 1).GetTotalMonthsFrom(new DateTime(2012, 12, 31)));
// Whole year
Assert.AreEqual(12, new DateTime(2012, 1, 1).GetTotalMonthsFrom(new DateTime(2013, 1, 1)));
// 29 Feb (leap) to 28 Feb (non-leap)
Assert.AreEqual(12, new DateTime(2012, 2, 29).GetTotalMonthsFrom(new DateTime(2013, 2, 28)));
// 100 years
Assert.AreEqual(1200, new DateTime(2000, 1, 1).GetTotalMonthsFrom(new DateTime(2100, 1, 1)));
// Same date
Assert.AreEqual(0, new DateTime(2014, 8, 5).GetTotalMonthsFrom(new DateTime(2014, 8, 5)));
// Past date
Assert.AreEqual(6, new DateTime(2012, 1, 1).GetTotalMonthsFrom(new DateTime(2011, 6, 10)));

Answer 11

首先，您必须定义 TotalMonths 的含义。
一个简单的定义是一个月为 30.4 天 (365.25 / 12)。

除此之外，任何包括分数的定义似乎都没用，而且更常见的整数值（日期之间的整月）也取决于非标准业务规则。

Answer 12

您需要根据日期时间自己计算出来。最后如何处理存根日将取决于您想用它做什么。

一种方法是计算月份，然后在最后修正天数。像这样的东西：

   DateTime start = new DateTime(2003, 12, 25);
   DateTime end = new DateTime(2009, 10, 6);
   int compMonth = (end.Month + end.Year * 12) - (start.Month + start.Year * 12);
   double daysInEndMonth = (end - end.AddMonths(1)).Days;
   double months = compMonth + (start.Day - end.Day) / daysInEndMonth;

Answer 13

对此没有太多明确的答案，因为你总是在假设事情。

此解决方案计算两个日期之间的月份，假设您要保存月份中的某一天进行比较（这意味着计算中会考虑该月中的某一天）

例如，如果您的日期为 2012 年 1 月 30 日和 2012 年 2 月 29 日不会是一个月，但 2013 年 3 月 1 日会。

它已经过非常彻底的测试，可能会在我们使用它之后清理它，并接受两个日期而不是时间跨度，这可能更好。希望这对其他人有帮助。

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
                dtThis.AddDays(daysinMonth - dtThis.Day);
            else
                dtThis.AddDays(dayOfMonth - dtThis.Day);
        }
        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
}

Answer 14

我会这样做：

static int TotelMonthDifference(this DateTime dtThis, DateTime dtOther)
{
    int intReturn = 0;

    dtThis = dtThis.Date.AddDays(-(dtThis.Day-1));
    dtOther = dtOther.Date.AddDays(-(dtOther.Day-1));

    while (dtOther.Date > dtThis.Date)
    {
        intReturn++;     
        dtThis = dtThis.AddMonths(1);
    }

    return intReturn;
}

Answer 15

当您想要完整的月份时，接受的答案非常有效。

我需要部分月份。这是我针对部分月份提出的解决方案：

    /// <summary>
    /// Calculate the difference in months.
    /// This will round up to count partial months.
    /// </summary>
    /// <param name="lValue"></param>
    /// <param name="rValue"></param>
    /// <returns></returns>
    public static int MonthDifference(DateTime lValue, DateTime rValue)
    {
        var yearDifferenceInMonths = (lValue.Year - rValue.Year) * 12;
        var monthDifference = lValue.Month - rValue.Month;

        return yearDifferenceInMonths + monthDifference + 
            (lValue.Day > rValue.Day
                ? 1 : 0); // If end day is greater than start day, add 1 to round up the partial month
    }

我还需要一年的差异，部分年份的需求也相同。这是我想出的解决方案：

    /// <summary>
    /// Calculate the differences in years.
    /// This will round up to catch partial months.
    /// </summary>
    /// <param name="lValue"></param>
    /// <param name="rValue"></param>
    /// <returns></returns>
    public static int YearDifference(DateTime lValue, DateTime rValue)
    {
        return lValue.Year - rValue.Year +
               (lValue.Month > rValue.Month // Partial month, same year
                   ? 1
                   : ((lValue.Month = rValue.Month) 
                     && (lValue.Day > rValue.Day)) // Partial month, same year and month
                   ? 1 : 0);
    }

Answer 16

我知道的老问题，但可能对某人有帮助。我在上面使用了 @Adam 接受的答案，但随后检查差异是否为 1 或 -1，然后检查是否是完整日历月的差异。因此 21/07/55 和 20/08/55 不会是一个完整的月份，但 21/07/55 和 21/07/55 会是。

/// <summary>
/// Amended date of birth cannot be greater than or equal to one month either side of original date of birth.
/// </summary>
/// <param name="dateOfBirth">Date of birth user could have amended.</param>
/// <param name="originalDateOfBirth">Original date of birth to compare against.</param>
/// <returns></returns>
public JsonResult ValidateDateOfBirth(string dateOfBirth, string originalDateOfBirth)
{
    DateTime dob, originalDob;
    bool isValid = false;

    if (DateTime.TryParse(dateOfBirth, out dob) && DateTime.TryParse(originalDateOfBirth, out originalDob))
    {
        int diff = ((dob.Month - originalDob.Month) + 12 * (dob.Year - originalDob.Year));

        switch (diff)
        {
            case 0:
                // We're on the same month, so ok.
                isValid = true;
                break;
            case -1:
                // The month is the previous month, so check if the date makes it a calendar month out.
                isValid = (dob.Day > originalDob.Day);
                break;
            case 1:
                // The month is the next month, so check if the date makes it a calendar month out.
                isValid = (dob.Day < originalDob.Day);
                break;
            default:
                // Either zero or greater than 1 month difference, so not ok.
                isValid = false;
                break;
        }
        if (!isValid)
            return Json("Date of Birth cannot be greater than one month either side of the date we hold.", JsonRequestBehavior.AllowGet);
    }
    else
    {
        return Json("Date of Birth is invalid.", JsonRequestBehavior.AllowGet);
    }
    return Json(true, JsonRequestBehavior.AllowGet);
}

Answer 17

case IntervalType.Month:
    returnValue = start.AddMonths(-end.Month).Month.ToString();
    break;
case IntervalType.Year:
    returnValue = (start.Year - end.Year).ToString();
    break;

Answer 18

月份的问题在于它并不是一个简单的衡量标准——它们的大小不是恒定的。您需要为要包含的内容定义规则，并从那里开始工作。例如，1 月 1 日到 2 月 1 日 - 您可以说涉及 2 个月，也可以说是 1 个月。那么“1 月 1 日 20:00”到“2 月 1 日 00:00”又如何——这并不是一个完整的月份。那是0吗？ 1？反过来呢（1月1日00:00到2月1日20:00）...1？ 2？

首先定义规则，然后你必须自己编写代码，恐怕......

Answer 19

如果您希望在 2 月 28 日 和 3 月 1 日 之间获得结果 1：

DateTime date1, date2;
int monthSpan = (date2.Year - date1.Year) * 12 + date2.Month - date1.Month

Answer 20

此库考虑 DateTime 的所有部分来计算月份差异：

// ----------------------------------------------------------------------
public void DateDiffSample()
{
  DateTime date1 = new DateTime( 2009, 11, 8, 7, 13, 59 );
  Console.WriteLine( "Date1: {0}", date1 );
  // > Date1: 08.11.2009 07:13:59
  DateTime date2 = new DateTime( 2011, 3, 20, 19, 55, 28 );
  Console.WriteLine( "Date2: {0}", date2 );
  // > Date2: 20.03.2011 19:55:28

  DateDiff dateDiff = new DateDiff( date1, date2 );

  // differences
  Console.WriteLine( "DateDiff.Years: {0}", dateDiff.Years );
  // > DateDiff.Years: 1
  Console.WriteLine( "DateDiff.Quarters: {0}", dateDiff.Quarters );
  // > DateDiff.Quarters: 5
  Console.WriteLine( "DateDiff.Months: {0}", dateDiff.Months );
  // > DateDiff.Months: 16
  Console.WriteLine( "DateDiff.Weeks: {0}", dateDiff.Weeks );
  // > DateDiff.Weeks: 70
  Console.WriteLine( "DateDiff.Days: {0}", dateDiff.Days );
  // > DateDiff.Days: 497
  Console.WriteLine( "DateDiff.Weekdays: {0}", dateDiff.Weekdays );
  // > DateDiff.Weekdays: 71
  Console.WriteLine( "DateDiff.Hours: {0}", dateDiff.Hours );
  // > DateDiff.Hours: 11940
  Console.WriteLine( "DateDiff.Minutes: {0}", dateDiff.Minutes );
  // > DateDiff.Minutes: 716441
  Console.WriteLine( "DateDiff.Seconds: {0}", dateDiff.Seconds );
  // > DateDiff.Seconds: 42986489

  // elapsed
  Console.WriteLine( "DateDiff.ElapsedYears: {0}", dateDiff.ElapsedYears );
  // > DateDiff.ElapsedYears: 1
  Console.WriteLine( "DateDiff.ElapsedMonths: {0}", dateDiff.ElapsedMonths );
  // > DateDiff.ElapsedMonths: 4
  Console.WriteLine( "DateDiff.ElapsedDays: {0}", dateDiff.ElapsedDays );
  // > DateDiff.ElapsedDays: 12
  Console.WriteLine( "DateDiff.ElapsedHours: {0}", dateDiff.ElapsedHours );
  // > DateDiff.ElapsedHours: 12
  Console.WriteLine( "DateDiff.ElapsedMinutes: {0}", dateDiff.ElapsedMinutes );
  // > DateDiff.ElapsedMinutes: 41
  Console.WriteLine( "DateDiff.ElapsedSeconds: {0}", dateDiff.ElapsedSeconds );
  // > DateDiff.ElapsedSeconds: 29
} // DateDiffSample

Answer 21

下面实际上是您可以做到的最准确的方法，因为“1个月”的定义根据它是哪个月份而变化，并且其他答案都没有考虑到这一点！如果您想了解有关框架中未内置问题的更多信息，您可以阅读这篇文章：具有 .Years 和 .Years 的真实时间跨度对象.Months （但是，阅读该文章并不是理解和使用下面的函数所必需的，它 100% 有效，没有其他人喜欢使用的近似值固有的不准确性 - 并且可以随意替换 .ReverseIt 函数使用您的框架上可能有的内置 .Reverse 函数（这里只是为了完整性），

请注意，您可以获得任意数量的日期/时间精度、秒和分钟，或秒、分钟和天，无论何时。到年（其中包含 6 个部分/段）。如果您指定前两个并且它已存在一年以上，则它将返回“1 年零 3 个月前”，并且不会返回其余部分，因为您已经请求了两个段。如果它只有几个小时，那么它只会返回“2 小时 1 分钟前”当然，如果您指定 1、2、3、4、5 或 6 个段（最大为 6，因为秒），则适用相同的规则。 、分钟、小时、天、月、年只有 6 种类型）它还会纠正语法问题，例如“分钟”与“分钟”，具体取决于它是否为 1 分钟或更长，所有类型都相同，以及生成的“字符串”。语法上总是正确的。

以下是一些使用示例：
bAllowSegments 标识要显示的段数...即：如果 3，则返回字符串将是（作为示例）... “3 年，2 个月和 13 天”（不包括小时、分钟和秒作为返回的前 3 个时间类别），但是，如果日期是较新的日期，例如几天前，则指定相同的段 (3) 将返回 “4 天，1小时 13 分钟前” 相反，所以它考虑了一切！

如果 bAllowSegments 为 2，则返回“3 年零 2 个月”，如果为 6（最大值）则返回“3 年、2 个月、13 天、13 小时、29 分钟和 9”秒”，但是，请注意，它永远不会返回这样的内容“0年，0个月，0天，3小时，2分13秒前”< /code> 因为它知道前 3 个段中没有日期数据并忽略它们，即使您指定了 6 个段，所以不用担心:)。当然，如果有一个段中包含 0，则在形成字符串时会考虑到这一点，并显示为 “3 天 4 秒前” 并忽略“0 小时”部分！喜欢的话请尽情享受并发表评论。

 Public Function RealTimeUntilNow(ByVal dt As DateTime, Optional ByVal bAllowSegments As Byte = 2) As String
  ' bAllowSegments identifies how many segments to show... ie: if 3, then return string would be (as an example)...
  ' "3 years, 2 months and 13 days" the top 3 time categories are returned, if bAllowSegments is 2 it would return
  ' "3 years and 2 months" and if 6 (maximum value) would return "3 years, 2 months, 13 days, 13 hours, 29 minutes and 9 seconds"
  Dim rYears, rMonths, rDays, rHours, rMinutes, rSeconds As Int16
  Dim dtNow = DateTime.Now
  Dim daysInBaseMonth = Date.DaysInMonth(dt.Year, dt.Month)

  rYears = dtNow.Year - dt.Year
  rMonths = dtNow.Month - dt.Month
  If rMonths < 0 Then rMonths += 12 : rYears -= 1 ' add 1 year to months, and remove 1 year from years.
  rDays = dtNow.Day - dt.Day
  If rDays < 0 Then rDays += daysInBaseMonth : rMonths -= 1
  rHours = dtNow.Hour - dt.Hour
  If rHours < 0 Then rHours += 24 : rDays -= 1
  rMinutes = dtNow.Minute - dt.Minute
  If rMinutes < 0 Then rMinutes += 60 : rHours -= 1
  rSeconds = dtNow.Second - dt.Second
  If rSeconds < 0 Then rSeconds += 60 : rMinutes -= 1

  ' this is the display functionality
  Dim sb As StringBuilder = New StringBuilder()
  Dim iSegmentsAdded As Int16 = 0

  If rYears > 0 Then sb.Append(rYears) : sb.Append(" year" & If(rYears <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rMonths > 0 Then sb.AppendFormat(rMonths) : sb.Append(" month" & If(rMonths <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rDays > 0 Then sb.Append(rDays) : sb.Append(" day" & If(rDays <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rHours > 0 Then sb.Append(rHours) : sb.Append(" hour" & If(rHours <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rMinutes > 0 Then sb.Append(rMinutes) : sb.Append(" minute" & If(rMinutes <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rSeconds > 0 Then sb.Append(rSeconds) : sb.Append(" second" & If(rSeconds <> 1, "s", "") & "") : iSegmentsAdded += 1

parseAndReturn:

  ' if the string is entirely empty, that means it was just posted so its less than a second ago, and an empty string getting passed will cause an error
  ' so we construct our own meaningful string which will still fit into the "Posted * ago " syntax...

  If sb.ToString = "" Then sb.Append("less than 1 second")

  Return ReplaceLast(sb.ToString.TrimEnd(" ", ",").ToString, ",", " and")

 End Function

当然，您将需要一个“ReplaceLast”函数，它接受一个源字符串、一个指定需要替换的内容的参数，以及另一个指定您想要替换它的内容的参数，并且它仅替换该字符串的最后一次出现...如果您没有或不想实现它，我已经包含了我的一个，所以就在这里，它将“按原样”工作，无需修改。我知道不再需要reverseit函数（存在于.net中），但是ReplaceLast和ReverseIt函数是从.net之前的时代遗留下来的，所以请原谅它看起来有多过时（仍然可以100％工作，一直在使用他们已经使用了十多年，可以保证它们没有错误）...:)。干杯。

<Extension()> _ 
Public Function ReplaceLast(ByVal sReplacable As String, ByVal sReplaceWhat As String, ByVal sReplaceWith As String) As String 
    ' let empty string arguments run, incase we dont know if we are sending and empty string or not. 
    sReplacable = sReplacable.ReverseIt 
    sReplacable = Replace(sReplacable, sReplaceWhat.ReverseIt, sReplaceWith.ReverseIt, , 1) ' only does first item on reversed version! 
    Return sReplacable.ReverseIt.ToString 
End Function 

<Extension()> _ 
Public Function ReverseIt(ByVal strS As String, Optional ByVal n As Integer = -1) As String 
    Dim strTempX As String = "", intI As Integer 

    If n > strS.Length Or n = -1 Then n = strS.Length 

    For intI = n To 1 Step -1 
        strTempX = strTempX + Mid(strS, intI, 1) 
    Next intI 

    ReverseIt = strTempX + Right(strS, Len(strS) - n) 

End Function 

Answer 22

如果您想要确切的数字，则不能仅从时间跨度中获得，因为您需要知道您正在处理哪些月份，以及是否正在处理闰年，就像您所说的那样。

要么获取一个大概的数字，要么对原始日期时间进行一些调整

Answer 23

http://www.astro.uu.nl/~ strous/AA/en/reken/juliaansedag.html

如果您可以将公历日期转换为儒略日数，您只需创建一个运算符来比较 zulian 日数，可以输入 double 来获取月、日、秒等。查看上面的链接以获取算法从格里高利转换为儒略。

Answer 24

在惯用的 C# 中没有内置方法可以准确地执行此操作。有一些解决方法，例如此 CodeProject 示例人们已经编码了。

Answer 25

如果您处理的是月份和年份，您需要知道每个月有多少天以及哪些年份是闰年。

输入公历（以及其他特定于文化的< a href="http://msdn.microsoft.com/en-us/library/system.globalization.calendar.aspx" rel="nofollow">日历 实现）。

虽然 Calendar 没有提供直接计算两个时间点之间差异的方法，但它确实提供了诸如

DateTime AddWeeks(DateTime time, int weeks)
DateTime AddMonths(DateTime time, int months)
DateTime AddYears(DateTime time, int years)

Answer 26

DateTime start = new DateTime(2003, 12, 25);
DateTime end = new DateTime(2009, 10, 6);
int compMonth = (end.Month + end.Year * 12) - (start.Month + start.Year * 12);
double daysInEndMonth = (end - end.AddMonths(1)).Days;
double months = compMonth + (start.Day - end.Day) / daysInEndMonth;

Answer 27

该方法返回一个包含 3 个元素的列表，第一个元素是年份，第二个元素是月份，最后一个元素是日期：

public static List<int> GetDurationInEnglish(DateTime from, DateTime to)
    {
        try
        {
            if (from > to)
                return null;

            var fY = from.Year;
            var fM = from.Month;
            var fD = DateTime.DaysInMonth(fY, fM);

            var tY = to.Year;
            var tM = to.Month;
            var tD = DateTime.DaysInMonth(tY, tM);

            int dY = 0;
            int dM = 0;
            int dD = 0;

            if (fD > tD)
            {
                tM--;

                if (tM <= 0)
                {
                    tY--;
                    tM = 12;
                    tD += DateTime.DaysInMonth(tY, tM);
                }
                else
                {
                    tD += DateTime.DaysInMonth(tY, tM);
                }
            }
            dD = tD - fD;

            if (fM > tM)
            {
                tY--;

                tM += 12;
            }
            dM = tM - fM;

            dY = tY - fY;

            return new List<int>() { dY, dM, dD };
        }
        catch (Exception exception)
        {
            //todo: log exception with parameters in db

            return null;
        }
    }