这里有一个DateTime扩展程序，它将年龄计算添加到DateTime对象。

public static class AgeExtender
{
    public static int GetAge(this DateTime dt)
    {
        int d = int.Parse(dt.ToString("yyyyMMdd"));
        int t = int.Parse(DateTime.Today.ToString("yyyyMMdd"));
        return (t-d)/10000;
    }
}

这是最准确的答案之一，它能够解决2月29日的生日，而不是2月28日的任何一年。

public int GetAge(DateTime birthDate)
{
    int age = DateTime.Now.Year - birthDate.Year;

    if (birthDate.DayOfYear > DateTime.Now.DayOfYear)
        age--;

    return age;
}

简单易懂的解决方案。

// Save today's date.
var today = DateTime.Today;

// Calculate the age.
var age = today.Year - birthdate.Year;

// Go back to the year in which the person was born in case of a leap year
if (birthdate.Date > today.AddYears(-age)) age--;

然而，这假设你在寻找西方的时代观念，而不是使用东亚的推算法。

这里有一个小的C#代码示例，我总结了一下，请注意边缘情况，特别是闰年，并不是所有上述解决方案都考虑到这些情况。将答案推出来作为DateTime可能会导致问题，因为你可能会在一个特定的月份中投入太多的时间，例如2月的30天。

public string LoopAge(DateTime myDOB, DateTime FutureDate)
{
    int years = 0;
    int months = 0;
    int days = 0;

    DateTime tmpMyDOB = new DateTime(myDOB.Year, myDOB.Month, 1);

    DateTime tmpFutureDate = new DateTime(FutureDate.Year, FutureDate.Month, 1);

    while (tmpMyDOB.AddYears(years).AddMonths(months) < tmpFutureDate)
    {
        months++;
        if (months > 12)
        {
            years++;
            months = months - 12;
        }
    }

    if (FutureDate.Day >= myDOB.Day)
    {
        days = days + FutureDate.Day - myDOB.Day;
    }
    else
    {
        months--;
        if (months < 0)
        {
            years--;
            months = months + 12;
        }
        days = days + (DateTime.DaysInMonth(FutureDate.AddMonths(-1).Year, FutureDate.AddMonths(-1).Month) + FutureDate.Day) - myDOB.Day;

    }

    //add an extra day if the dob is a leap day
    if (DateTime.IsLeapYear(myDOB.Year) && myDOB.Month == 2 && myDOB.Day == 29)
    {
        //but only if the future date is less than 1st March
        if(FutureDate >= new DateTime(FutureDate.Year, 3,1))
            days++;
    }

    return "Years: " + years + " Months: " + months + " Days: " + days;
}

这不是一个直接的答案，但更多的是从准科学的角度对当前问题进行哲学推理。

我认为，这个问题并没有具体说明衡量年龄的单位或文化，大多数答案似乎都假设了一个整数年表示。时间的国际单位制单位是秒，因此正确的通用答案应该是（当然，假设标准化日期时间，不考虑相对论效应）：

var lifeInSeconds = (DateTime.Now.Ticks - then.Ticks)/TickFactor;

在基督教以年计算年龄的方法中：

var then = ... // Then, in this case the birthday
var now = DateTime.UtcNow;
int age = now.Year - then.Year;
if (now.AddYears(-age) < then) age--;

在金融领域，当计算通常被称为日计数分数（Day Count Fraction）的东西时，也存在类似的问题，该分数大致是给定时期的年数。年龄问题确实是一个衡量时间的问题。

实际/实际（正确计算所有天数）惯例示例：

DateTime start, end = .... // Whatever, assume start is before end

double startYearContribution = 1 - (double) start.DayOfYear / (double) (DateTime.IsLeapYear(start.Year) ? 366 : 365);
double endYearContribution = (double)end.DayOfYear / (double)(DateTime.IsLeapYear(end.Year) ? 366 : 365);
double middleContribution = (double) (end.Year - start.Year - 1);

double DCF = startYearContribution + endYearContribution + middleContribution;

另一种很常见的衡量时间的方法通常是“序列化”（命名这一日期惯例的家伙一定是认真的“trippin”）：

DateTime start, end = .... // Whatever, assume start is before end
int days = (end - start).Days;

我想知道，在相对论年龄（以秒为单位）变得比迄今为止地球围绕太阳周期的粗略近似更有用之前，我们还需要多长时间：）或者换句话说，当一个周期必须给定一个位置或一个表示其自身运动的函数才能有效时：）

private int GetYearDiff(DateTime start, DateTime end)
{
    int diff = end.Year - start.Year;
    if (end.DayOfYear < start.DayOfYear) { diff -= 1; }
    return diff;
}
[Fact]
public void GetYearDiff_WhenCalls_ShouldReturnCorrectYearDiff()
{
    //arrange
    var now = DateTime.Now;
    //act
    //assert
    Assert.Equal(24, GetYearDiff(new DateTime(1992, 7, 9), now)); // passed
    Assert.Equal(24, GetYearDiff(new DateTime(1992, now.Month, now.Day), now)); // passed
    Assert.Equal(23, GetYearDiff(new DateTime(1992, 12, 9), now)); // passed
}