questions - stackoverflow c#




Wie berechne ich das Alter einer Person in C#? (20)

Der einfachste Weg, den ich je gefunden habe, ist dieser. Es funktioniert korrekt für die Regionen USA und Westeuropa. Ich kann nicht mit anderen Orten sprechen, insbesondere mit Orten wie China. 4 zusätzliche vergleicht höchstens nach der anfänglichen Berechnung des Alters.

public int AgeInYears(DateTime birthDate, DateTime referenceDate)
{
  Debug.Assert(referenceDate >= birthDate, 
               "birth date must be on or prior to the reference date");

  DateTime birth = birthDate.Date;
  DateTime reference = referenceDate.Date;
  int years = (reference.Year - birth.Year);

  //
  // an offset of -1 is applied if the birth date has 
  // not yet occurred in the current year.
  //
  if (reference.Month > birth.Month);
  else if (reference.Month < birth.Month) 
    --years;
  else // in birth month
  {
    if (reference.Day < birth.Day)
      --years;
  }

  return years ;
}

Ich habe die Antworten darauf durchgesehen und festgestellt, dass niemand auf regulatorische / rechtliche Auswirkungen von Schalttagsgeburten hingewiesen hat. Wenn Sie beispielsweise gemäß Wikipedia am 29. Februar in verschiedenen Gerichtsbarkeiten geboren sind, ist Ihr Nicht-Schaltjahr-Geburtstag unterschiedlich:

  • In Großbritannien und Hongkong: Es ist der Jahrestag. Am nächsten Tag ist der 1. März Ihr Geburtstag.
  • In Neuseeland: Es ist der Vortag, der 28. Februar für die Zwecke der Fahrerlaubnis und der 1. März für andere Zwecke.
  • Taiwan: Es ist der 28. Februar.

Und soweit ich das beurteilen kann, schweigen die Statuten in den USA in dieser Angelegenheit und überlassen es dem Common Law und der Art und Weise, wie verschiedene Aufsichtsbehörden die Dinge in ihren Vorschriften definieren.

Zu diesem Zweck eine Verbesserung:

public enum LeapDayRule
{
  OrdinalDay     = 1 ,
  LastDayOfMonth = 2 ,
}

static int ComputeAgeInYears(DateTime birth, DateTime reference, LeapYearBirthdayRule ruleInEffect)
{
  bool isLeapYearBirthday = CultureInfo.CurrentCulture.Calendar.IsLeapDay(birth.Year, birth.Month, birth.Day);
  DateTime cutoff;

  if (isLeapYearBirthday && !DateTime.IsLeapYear(reference.Year))
  {
    switch (ruleInEffect)
    {
      case LeapDayRule.OrdinalDay:
        cutoff = new DateTime(reference.Year, 1, 1)
                             .AddDays(birth.DayOfYear - 1);
        break;

      case LeapDayRule.LastDayOfMonth:
        cutoff = new DateTime(reference.Year, birth.Month, 1)
                             .AddMonths(1)
                             .AddDays(-1);
        break;

      default:
        throw new InvalidOperationException();
    }
  }
  else
  {
    cutoff = new DateTime(reference.Year, birth.Month, birth.Day);
  }

  int age = (reference.Year - birth.Year) + (reference >= cutoff ? 0 : -1);
  return age < 0 ? 0 : age;
}

Es ist zu beachten, dass dieser Code Folgendes voraussetzt:

  • Eine westliche (europäische) Altersrechnung, und
  • Ein Kalender wie der Gregorianische Kalender, der am Ende eines Monats einen einzelnen Schalttag einfügt.

Wie berechne ich das Alter einer Person in Jahren, DateTime ein DateTime für den Geburtstag einer Person angegeben ist?


Der folgende Ansatz (Auszug aus der Time Period Library für die .NET- Klasse DateDiff ) berücksichtigt den Kalender der Kulturinformationen:

// ----------------------------------------------------------------------
private static int YearDiff( DateTime date1, DateTime date2 )
{
  return YearDiff( date1, date2, DateTimeFormatInfo.CurrentInfo.Calendar );
} // YearDiff

// ----------------------------------------------------------------------
private static int YearDiff( DateTime date1, DateTime date2, Calendar calendar )
{
  if ( date1.Equals( date2 ) )
  {
    return 0;
  }

  int year1 = calendar.GetYear( date1 );
  int month1 = calendar.GetMonth( date1 );
  int year2 = calendar.GetYear( date2 );
  int month2 = calendar.GetMonth( date2 );

  // find the the day to compare
  int compareDay = date2.Day;
  int compareDaysPerMonth = calendar.GetDaysInMonth( year1, month1 );
  if ( compareDay > compareDaysPerMonth )
  {
    compareDay = compareDaysPerMonth;
  }

  // build the compare date
  DateTime compareDate = new DateTime( year1, month2, compareDay,
    date2.Hour, date2.Minute, date2.Second, date2.Millisecond );
  if ( date2 > date1 )
  {
    if ( compareDate < date1 )
    {
      compareDate = compareDate.AddYears( 1 );
    }
  }
  else
  {
    if ( compareDate > date1 )
    {
      compareDate = compareDate.AddYears( -1 );
    }
  }
  return year2 - calendar.GetYear( compareDate );
} // YearDiff

Verwendung:

// ----------------------------------------------------------------------
public void CalculateAgeSamples()
{
  PrintAge( new DateTime( 2000, 02, 29 ), new DateTime( 2009, 02, 28 ) );
  // > Birthdate=29.02.2000, Age at 28.02.2009 is 8 years
  PrintAge( new DateTime( 2000, 02, 29 ), new DateTime( 2012, 02, 28 ) );
  // > Birthdate=29.02.2000, Age at 28.02.2012 is 11 years
} // CalculateAgeSamples

// ----------------------------------------------------------------------
public void PrintAge( DateTime birthDate, DateTime moment )
{
  Console.WriteLine( "Birthdate={0:d}, Age at {1:d} is {2} years", birthDate, moment, YearDiff( birthDate, moment ) );
} // PrintAge

Dies ist keine direkte Antwort, sondern eher eine philosophische Begründung des vorliegenden Problems aus quasi wissenschaftlicher Sicht.

Ich würde argumentieren, dass die Frage weder die Einheit noch die Kultur angibt, in der das Alter gemessen werden soll. Die meisten Antworten scheinen eine ganzzahlige jährliche Repräsentation anzunehmen. Die SI-Einheit für die Zeit ist second , ergo, die richtige generische Antwort sollte sein (natürlich unter der Annahme normalisierter DateTime und überhaupt nicht berücksichtigender relativistischer Effekte):

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

In der christlichen Art, das Alter in Jahren zu berechnen:

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

In der Finanzbranche gibt es ein ähnliches Problem bei der Berechnung eines häufig als Tageszählungsbruch bezeichneten Betrags , der ungefähr einige Jahre für einen bestimmten Zeitraum beträgt. Und die Altersfrage ist wirklich eine Frage der Zeitmessung.

Beispiel für die aktuelle / aktuelle (alle Tage "richtig" zählen) Konvention:

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;

Ein anderer, allgemein üblicher Weg, um die Zeit zu messen, ist das "Serialisieren" (der Typ, der diese Datumskonvention nannte, muss ernsthaft ausgelassen haben):

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

Ich frage mich, wie lange es dauern muss, bis ein relativistisches Zeitalter in Sekunden nützlicher ist als die grobe Annäherung von Erd- und Sonnenzyklen zu Lebzeiten eine Funktion, die Bewegung für sich selbst darstellt, um gültig zu sein :)


Diese klassische Frage verdient eine Lösung von Noda Time .

static int GetAge(LocalDate dateOfBirth)
{
    Instant now = SystemClock.Instance.Now;

    // The target time zone is important.
    // It should align with the *current physical location* of the person
    // you are talking about.  When the whereabouts of that person are unknown,
    // then you use the time zone of the person who is *asking* for the age.
    // The time zone of birth is irrelevant!

    DateTimeZone zone = DateTimeZoneProviders.Tzdb["America/New_York"];

    LocalDate today = now.InZone(zone).Date;

    Period period = Period.Between(dateOfBirth, today, PeriodUnits.Years);

    return (int) period.Years;
}

Verwendung:

LocalDate dateOfBirth = new LocalDate(1976, 8, 27);
int age = GetAge(dateOfBirth);

Möglicherweise interessieren Sie auch die folgenden Verbesserungen:

  • Das Eingeben der Uhrzeit IClock anstelle der Verwendung SystemClock.Instance würde die Testbarkeit verbessern.

  • Die Zielzeitzone wird sich wahrscheinlich ändern, daher möchten Sie auch einen DateTimeZone Parameter.

Siehe auch meinen Blogbeitrag zu diesem Thema: Umgang mit Geburtstagen und anderen Jahrestagen


Hier ist eine Lösung.

DateTime dateOfBirth = new DateTime(2000, 4, 18);
DateTime currentDate = DateTime.Now;

int ageInYears = 0;
int ageInMonths = 0;
int ageInDays = 0;

ageInDays = currentDate.Day - dateOfBirth.Day;
ageInMonths = currentDate.Month - dateOfBirth.Month;
ageInYears = currentDate.Year - dateOfBirth.Year;

if (ageInDays < 0)
{
    ageInDays += DateTime.DaysInMonth(currentDate.Year, currentDate.Month);
    ageInMonths = ageInMonths--;

    if (ageInMonths < 0)
    {
        ageInMonths += 12;
        ageInYears--;
    }
}

if (ageInMonths < 0)
{
    ageInMonths += 12;
    ageInYears--;
}

Console.WriteLine("{0}, {1}, {2}", ageInYears, ageInMonths, ageInDays);

Ich habe die ScArcher2-Lösung für eine genaue Jahresberechnung eines Personenalters verwendet, aber ich musste sie weiterentwickeln und ihre Monate und Tage zusammen mit den Jahren berechnen.

    public static Dictionary<string,int> CurrentAgeInYearsMonthsDays(DateTime? ndtBirthDate, DateTime? ndtReferralDate)
    {
        //----------------------------------------------------------------------
        // Can't determine age if we don't have a dates.
        //----------------------------------------------------------------------
        if (ndtBirthDate == null) return null;
        if (ndtReferralDate == null) return null;

        DateTime dtBirthDate = Convert.ToDateTime(ndtBirthDate);
        DateTime dtReferralDate = Convert.ToDateTime(ndtReferralDate);

        //----------------------------------------------------------------------
        // Create our Variables
        //----------------------------------------------------------------------
        Dictionary<string, int> dYMD = new Dictionary<string,int>();
        int iNowDate, iBirthDate, iYears, iMonths, iDays;
        string sDif = "";

        //----------------------------------------------------------------------
        // Store off current date/time and DOB into local variables
        //---------------------------------------------------------------------- 
        iNowDate = int.Parse(dtReferralDate.ToString("yyyyMMdd"));
        iBirthDate = int.Parse(dtBirthDate.ToString("yyyyMMdd"));

        //----------------------------------------------------------------------
        // Calculate Years
        //----------------------------------------------------------------------
        sDif = (iNowDate - iBirthDate).ToString();
        iYears = int.Parse(sDif.Substring(0, sDif.Length - 4));

        //----------------------------------------------------------------------
        // Store Years in Return Value
        //----------------------------------------------------------------------
        dYMD.Add("Years", iYears);

        //----------------------------------------------------------------------
        // Calculate Months
        //----------------------------------------------------------------------
        if (dtBirthDate.Month > dtReferralDate.Month)
            iMonths = 12 - dtBirthDate.Month + dtReferralDate.Month - 1;
        else
            iMonths = dtBirthDate.Month - dtReferralDate.Month;

        //----------------------------------------------------------------------
        // Store Months in Return Value
        //----------------------------------------------------------------------
        dYMD.Add("Months", iMonths);

        //----------------------------------------------------------------------
        // Calculate Remaining Days
        //----------------------------------------------------------------------
        if (dtBirthDate.Day > dtReferralDate.Day)
            //Logic: Figure out the days in month previous to the current month, or the admitted month.
            //       Subtract the birthday from the total days which will give us how many days the person has lived since their birthdate day the previous month.
            //       then take the referral date and simply add the number of days the person has lived this month.

            //If referral date is january, we need to go back to the following year's December to get the days in that month.
            if (dtReferralDate.Month == 1)
                iDays = DateTime.DaysInMonth(dtReferralDate.Year - 1, 12) - dtBirthDate.Day + dtReferralDate.Day;       
            else
                iDays = DateTime.DaysInMonth(dtReferralDate.Year, dtReferralDate.Month - 1) - dtBirthDate.Day + dtReferralDate.Day;       
        else
            iDays = dtReferralDate.Day - dtBirthDate.Day;             

        //----------------------------------------------------------------------
        // Store Days in Return Value
        //----------------------------------------------------------------------
        dYMD.Add("Days", iDays);

        return dYMD;
}

SQL-Version:

declare @dd smalldatetime = '1980-04-01'
declare @age int = YEAR(GETDATE())-YEAR(@dd)
if (@dd> DATEADD(YYYY, -@age, GETDATE())) set @age = @age -1

print @age  

Wie wäre es mit dieser Lösung?

static string CalcAge(DateTime birthDay)
{
    DateTime currentDate = DateTime.Now;         
    int approximateAge = currentDate.Year - birthDay.Year;
    int daysToNextBirthDay = (birthDay.Month * 30 + birthDay.Day) - 
        (currentDate.Month * 30 + currentDate.Day) ;

    if (approximateAge == 0 || approximateAge == 1)
    {                
        int month =  Math.Abs(daysToNextBirthDay / 30);
        int days = Math.Abs(daysToNextBirthDay % 30);

        if (month == 0)
            return "Your age is: " + daysToNextBirthDay + " days";

        return "Your age is: " + month + " months and " + days + " days"; ;
    }

    if (daysToNextBirthDay > 0)
        return "Your age is: " + --approximateAge + " Years";

    return "Your age is: " + approximateAge + " Years"; ;
}

Der beste Weg, den ich aufgrund von Schaltjahren kenne und alles ist:

DateTime birthDate = new DateTime(2000,3,1);
int age = (int)Math.Floor((DateTime.Now - birthDate).TotalDays / 365.25D);

Hoffe das hilft.


Die einfache Antwort darauf ist, AddYears wie unten gezeigt anzuwenden, da dies die einzige native Methode ist, um Jahre zum 29. Februar von Schaltjahren hinzuzufügen und das korrekte Ergebnis vom 28. Februar für gemeinsame Jahre zu erhalten.

Einige glauben, dass der 1. März der Geburtstag der Sprünge ist, aber weder .Net noch eine offizielle Regel stützen dies, noch erklärt eine gemeinsame Logik, warum manche im Februar geborene Kinder 75% ihrer Geburtstage in einem anderen Monat haben sollten.

Darüber hinaus bietet sich eine Age-Methode an, um DateTime zu DateTime . Auf diese Weise können Sie das Alter auf einfachste Weise ermitteln:

  1. Listenpunkt

int age = birthDate.Age ();

public static class DateTimeExtensions
{
    /// <summary>
    /// Calculates the age in years of the current System.DateTime object today.
    /// </summary>
    /// <param name="birthDate">The date of birth</param>
    /// <returns>Age in years today. 0 is returned for a future date of birth.</returns>
    public static int Age(this DateTime birthDate)
    {
        return Age(birthDate, DateTime.Today);
    }

    /// <summary>
    /// Calculates the age in years of the current System.DateTime object on a later date.
    /// </summary>
    /// <param name="birthDate">The date of birth</param>
    /// <param name="laterDate">The date on which to calculate the age.</param>
    /// <returns>Age in years on a later day. 0 is returned as minimum.</returns>
    public static int Age(this DateTime birthDate, DateTime laterDate)
    {
        int age;
        age = laterDate.Year - birthDate.Year;

        if (age > 0)
        {
            age -= Convert.ToInt32(laterDate.Date < birthDate.Date.AddYears(age));
        }
        else
        {
            age = 0;
        }

        return age;
    }
}

Führen Sie nun diesen Test aus:

class Program
{
    static void Main(string[] args)
    {
        RunTest();
    }

    private static void RunTest()
    {
        DateTime birthDate = new DateTime(2000, 2, 28);
        DateTime laterDate = new DateTime(2011, 2, 27);
        string iso = "yyyy-MM-dd";

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                Console.WriteLine("Birth date: " + birthDate.AddDays(i).ToString(iso) + "  Later date: " + laterDate.AddDays(j).ToString(iso) + "  Age: " + birthDate.AddDays(i).Age(laterDate.AddDays(j)).ToString());
            }
        }

        Console.ReadKey();
    }
}

Das Beispiel für ein kritisches Datum lautet wie folgt:

Geburtsdatum: 2000-02-29 Späteres Datum: 2011-02-28 Alter: 11

Ausgabe:

{
    Birth date: 2000-02-28  Later date: 2011-02-27  Age: 10
    Birth date: 2000-02-28  Later date: 2011-02-28  Age: 11
    Birth date: 2000-02-28  Later date: 2011-03-01  Age: 11
    Birth date: 2000-02-29  Later date: 2011-02-27  Age: 10
    Birth date: 2000-02-29  Later date: 2011-02-28  Age: 11
    Birth date: 2000-02-29  Later date: 2011-03-01  Age: 11
    Birth date: 2000-03-01  Later date: 2011-02-27  Age: 10
    Birth date: 2000-03-01  Later date: 2011-02-28  Age: 10
    Birth date: 2000-03-01  Later date: 2011-03-01  Age: 11
}

Und für das spätere Datum 28.02.2012:

{
    Birth date: 2000-02-28  Later date: 2012-02-28  Age: 12
    Birth date: 2000-02-28  Later date: 2012-02-29  Age: 12
    Birth date: 2000-02-28  Later date: 2012-03-01  Age: 12
    Birth date: 2000-02-29  Later date: 2012-02-28  Age: 11
    Birth date: 2000-02-29  Later date: 2012-02-29  Age: 12
    Birth date: 2000-02-29  Later date: 2012-03-01  Age: 12
    Birth date: 2000-03-01  Later date: 2012-02-28  Age: 11
    Birth date: 2000-03-01  Later date: 2012-02-29  Age: 11
    Birth date: 2000-03-01  Later date: 2012-03-01  Age: 12
}

Dies ist die Version, die wir hier verwenden. Es funktioniert und es ist ziemlich einfach. Es ist die gleiche Idee wie bei Jeff, aber ich denke, es ist etwas klarer, weil es die Logik für das Subtrahieren von eins trennt, so dass es ein bisschen einfacher zu verstehen ist.

public static int GetAge(this DateTime dateOfBirth, DateTime dateAsAt)
{
    return dateAsAt.Year - dateOfBirth.Year - (dateOfBirth.DayOfYear < dateAsAt.DayOfYear ? 0 : 1);
}

Sie können den ternären Operator erweitern, um es noch klarer zu machen, wenn Sie der Meinung sind, dass solche Dinge unklar sind.

DateTime wird dies als Erweiterungsmethode für DateTime , aber Sie können sich natürlich diese eine DateTime schnappen, die die Arbeit erledigt, und sie irgendwo DateTime . Hier haben wir eine weitere Überladung der Extension-Methode, die der DateTime.Now in DateTime.Now wird.


Dies ist eine seltsame Methode, aber wenn Sie das Datum auf yyyymmdd und das Geburtsdatum vom aktuellen Datum abziehen, dann yyyymmdd Sie die letzten 4 Ziffern, die Sie das Alter haben :)

Ich kenne C # nicht, aber ich glaube, dass dies in jeder Sprache funktionieren wird.

20080814 - 19800703 = 280111 

Löschen Sie die letzten 4 Ziffern = 28 .

C # -Code:

int now = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
int dob = int.Parse(dateOfBirth.ToString("yyyyMMdd"));
int age = (now - dob) / 10000;

Oder alternativ ohne die gesamte Typkonvertierung in Form einer Erweiterungsmethode. Fehlerprüfung entfällt:

public static Int32 GetAge(this DateTime dateOfBirth)
{
    var today = DateTime.Today;

    var a = (today.Year * 100 + today.Month) * 100 + today.Day;
    var b = (dateOfBirth.Year * 100 + dateOfBirth.Month) * 100 + dateOfBirth.Day;

    return (a - b) / 10000;
}

Eine leicht verständliche und einfache Lösung.

// Save today's date.
var today = DateTime.Today;
// Calculate the age.
var age = today.Year - birthdate.Year;
// Go back to the year the person was born in case of a leap year
if (birthdate.Date > today.AddYears(-age)) age--;

Dies setzt jedoch voraus, dass Sie die westliche Idee des Alters suchen und keine ostasiatische Abrechnung verwenden .


Hier ist noch eine andere Antwort:

public static int AgeInYears(DateTime birthday, DateTime today)
{
    return ((today.Year - birthday.Year) * 372 + (today.Month - birthday.Month) * 31 + (today.Day - birthday.Day)) / 372;
}

Dies wurde ausgiebig Unit-getestet. Es sieht ein bisschen "magisch" aus. Die Zahl 372 ist die Anzahl der Tage in einem Jahr, wenn jeder Monat 31 Tage hätte.

Die Erklärung, warum es funktioniert ( von hier aufgehoben ), ist:

Yn = DateTime.Now.Year, Yb = birthday.Year, Mn = DateTime.Now.Month, Mb = birthday.Month, Dn = DateTime.Now.Day, Db = birthday.Day wir Yn = DateTime.Now.Year, Yb = birthday.Year, Mn = DateTime.Now.Month, Mb = birthday.Month, Dn = DateTime.Now.Day, Db = birthday.Day

age = Yn - Yb + (31*(Mn - Mb) + (Dn - Db)) / 372

Wir wissen, dass wir entweder Yn-Yb benötigen, wenn das Datum bereits erreicht wurde, Yn-Yb-1 wenn dies nicht der Yn-Yb-1 ist.

a) Wenn Mn<Mb , haben wir -341 <= 31*(Mn-Mb) <= -31 and -30 <= Dn-Db <= 30

-371 <= 31*(Mn - Mb) + (Dn - Db) <= -1

Mit ganzzahliger Division

(31*(Mn - Mb) + (Dn - Db)) / 372 = -1

b) Wenn Mn=Mb und Dn<Db , haben wir 31*(Mn - Mb) = 0 and -30 <= Dn-Db <= -1

Wieder mit ganzzahliger Division

(31*(Mn - Mb) + (Dn - Db)) / 372 = -1

c) Wenn Mn>Mb , haben wir 31 <= 31*(Mn-Mb) <= 341 and -30 <= Dn-Db <= 30

1 <= 31*(Mn - Mb) + (Dn - Db) <= 371

Mit ganzzahliger Division

(31*(Mn - Mb) + (Dn - Db)) / 372 = 0

d) Wenn Mn=Mb und Dn>Db , haben wir 31*(Mn - Mb) = 0 and 1 <= Dn-Db <= 3 0

Wieder mit ganzzahliger Division

(31*(Mn - Mb) + (Dn - Db)) / 372 = 0

e) Wenn Mn=Mb und Dn=Db , haben wir 31*(Mn - Mb) + Dn-Db = 0

und daher (31*(Mn - Mb) + (Dn - Db)) / 372 = 0


Ich bin zu spät zur Party, aber hier ist ein Einzeiler:

int age = new DateTime(DateTime.Now.Subtract(birthday).Ticks).Year-1;

Ich denke, keine der bisherigen Antworten sieht Kulturen vor, die das Alter anders berechnen. Siehe zum Beispiel das ostasiatische Zeitalter im Vergleich zum Westen.

Jede echte Antwort muss Lokalisierung beinhalten. Das Strategiemuster wäre in diesem Beispiel wahrscheinlich in Ordnung.


Ich habe einige Zeit damit verbracht, mich damit zu befassen und das Alter in Jahren, Monaten und Tagen zu berechnen. Ich habe gegen das Problem am 29. Februar und Schaltjahre getestet und es scheint zu funktionieren, ich würde mich über jedes Feedback freuen:

public void 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 +=
            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++;
    }

}

Ich weiß nicht, wie die falsche Lösung akzeptiert werden kann. Das korrekte C # -Snippet wurde von Michael Stum geschrieben

Hier ist ein Testschnipsel:

DateTime bDay = new DateTime(2000, 2, 29);
DateTime now = new DateTime(2009, 2, 28);
MessageBox.Show(string.Format("Test {0} {1} {2}",
                CalculateAgeWrong1(bDay, now),      // outputs 9
                CalculateAgeWrong2(bDay, now),      // outputs 9
                CalculateAgeCorrect(bDay, now),     // outputs 8
                CalculateAgeCorrect2(bDay, now)));  // outputs 8

Hier haben Sie die Methoden:

public int CalculateAgeWrong1(DateTime birthDate, DateTime now)
{
    return new DateTime(now.Subtract(birthDate).Ticks).Year - 1;
}

public int CalculateAgeWrong2(DateTime birthDate, DateTime now)
{
    int age = now.Year - birthDate.Year;

    if (now < birthDate.AddYears(age))
        age--;

    return age;
}

public int CalculateAgeCorrect(DateTime birthDate, DateTime now)
{
    int age = now.Year - birthDate.Year;

    if (now.Month < birthDate.Month || (now.Month == birthDate.Month && now.Day < birthDate.Day))
        age--;

    return age;
}

public int CalculateAgeCorrect2(DateTime birthDate, DateTime now)
{
    int age = now.Year - birthDate.Year;

    // for leap years we need this
    if (birthDate > now.AddYears(-age)) age--;
    // don't use:
    // if (birthDate.AddYears(age) > now) age--;

    return age;
}

Mein Vorschlag

int age = (int) ((DateTime.Now - bday).TotalDays/365.242199);

Das Jahr scheint sich zum richtigen Zeitpunkt zu ändern. (Ich vor Ort getestet bis zum Alter von 107)


private int GetAge(int _year, int _month, int _day
{
    DateTime yourBirthDate= new DateTime(_year, _month, _day);

    DateTime todaysDateTime = DateTime.Today;
    int noOfYears = todaysDateTime.Year - yourBirthDate.Year;

    if (DateTime.Now.Month < yourBirthDate.Month ||
        (DateTime.Now.Month == yourBirthDate.Month && DateTime.Now.Day < yourBirthDate.Day))
    {
        noOfYears--;
    }

    return  noOfYears;
}






datetime