Hoe bereken ik iemands leeftijd in C #?

stemmen
1k

Gegeven een DateTimewat neerkomt op de verjaardag van een persoon, hoe kan ik het berekenen van hun leeftijd in jaren?

De vraag is gesteld op 01/08/2008 om 00:40
bron van user
In andere talen...                            


64 antwoorden

stemmen
1k

Een eenvoudig te begrijpen en eenvoudige oplossing.

// 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 > today.AddYears(-age)) age--;

Echter, dit veronderstelt dat je op zoek bent naar de westerse idee van de leeftijd en het niet gebruiken van Oost-Aziatische afrekening .

antwoordde op 04/08/2008 om 17:50
bron van user

stemmen
874

Dit is een vreemde manier om het te doen, maar als u de datumnotatie aan yyyymmdden aftrekken van de geboortedatum van de huidige datum dan vallen de laatste 4 cijfers die u de leeftijd hebt :)

Ik weet niet C #, maar ik denk dat dit zal werken in elke taal.

20080814 - 19800703 = 280111 

Laat de laatste 4 cijfers = 28.

C # Code:

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

Of als alternatief zonder de conversie in de vorm van een extension method. Foutcontrole weggelaten:

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;
}
antwoordde op 15/08/2008 om 04:47
bron van user

stemmen
336

Ik weet niet hoe de verkeerde oplossing kan worden aanvaard. De juiste C # fragment werd geschreven door Michael Stum

Hier is een test fragment:

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

Hier heeft u de 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;
}
antwoordde op 20/10/2009 om 16:07
bron van user

stemmen
113

Ik denk niet dat een van de antwoorden tot nu toe voor culturen die leeftijd anders te berekenen. Zie bijvoorbeeld, Oost-Aziatische Age Reckoning ten opzichte van dat in het Westen.

Elke echte antwoord moet lokalisatie bevatten. De Strategy Pattern zou waarschijnlijk zijn om in dit voorbeeld.

antwoordde op 17/08/2008 om 18:14
bron van user

stemmen
98

Het simpele antwoord hierop is toe te passen AddYears, zoals hieronder weergegeven, want dit is de enige inheemse methode om jaar toe te voegen aan de 29 februari van schrikkeljaren en het juiste resultaat van de 28 februari voor de gemeenschappelijke jaar te verkrijgen.

Sommigen vinden dat 1 maart is de verjaardag van leaplings maar noch .Net noch enige officiële regel steunt dit, noch gemeenschappelijke logica verklaren waarom sommige geboren in februari 75% van hun verjaardag zou moeten hebben in een andere maand.

Verder kan een leeftijd werkwijze leent zich te voegen als een uitbreiding DateTime. Hierdoor kunt u de leeftijd op de meest eenvoudige manier te verkrijgen:

  1. lijstitem

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;
    }
}

Nu, voert deze test:

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();
    }
}

De kritische datum voorbeeld is dit:

Geboortedatum: 2000/02/29 latere datum: 2011-02-28 Leeftijd: 11

Output:

{
    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
}

En voor de latere datum 2012-02-28:

{
    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
}
antwoordde op 20/02/2011 om 00:56
bron van user

stemmen
74

Mijn suggestie

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

Dat lijkt het jaar wijzigen op de juiste datum te hebben. (I spot getest tot leeftijd 107)

antwoordde op 03/10/2008 om 21:19
bron van user

stemmen
61

Een andere functie, niet door mij, maar vinden op het web en verfijnd het een beetje:

public static int GetAge(DateTime birthDate)
{
    DateTime n = DateTime.Now; // To avoid a race condition around midnight
    int age = n.Year - birthDate.Year;

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

    return age;
}

Slechts twee dingen die in mijn gedachten komen: Hoe zit het met mensen uit landen die wel de gregoriaanse kalender niet gebruiken? DateTime.Now is in de server-specifieke cultuur denk ik. Ik heb absoluut 0 kennis over de werkelijk aan de slag met Aziatische kalenders en ik weet niet of er is een eenvoudige manier om data tussen agenda te zetten, maar voor het geval je je afvraagt ​​over die chinese jongens van het jaar 4660 :-)

antwoordde op 01/08/2008 om 22:46
bron van user

stemmen
43

2 Belangrijkste problemen op te lossen zijn:

1. Bereken Exact leeftijd - in jaren, maanden, dagen, enz.

2. Bereken het algemeen waargenomen leeftijd - mensen meestal niet uit hoe oud ze precies zijn, ze geven net wanneer hun verjaardag in het lopende jaar is.


Oplossing voor 1 ligt voor de hand:

DateTime birth = DateTime.Parse("1.1.2000");
DateTime today = DateTime.Today;     //we usually don't care about birth time
TimeSpan age = today - birth;        //.NET FCL should guarantee this as precise
double ageInDays = age.TotalDays;    //total number of days ... also precise
double daysInYear = 365.2425;        //statistical value for 400 years
double ageInYears = ageInDays / daysInYear;  //can be shifted ... not so precise

Oplossing voor 2 is degene die niet zo precies te zijn in het bepalen van de totale leeftijd, maar zo nauwkeurig wordt ervaren door mensen. Mensen meestal ook gebruiken, wanneer zij hun leeftijd "handmatig" te berekenen:

DateTime birth = DateTime.Parse("1.1.2000");
DateTime today = DateTime.Today;
int age = today.Year - birth.Year;    //people perceive their age in years

if (today.Month < birth.Month ||
   ((today.Month == birth.Month) && (today.Day < birth.Day)))
{
  age--;  //birthday in current year not yet reached, we are 1 year younger ;)
          //+ no birthday for 29.2. guys ... sorry, just wrong date for birth
}

Toelichting op 2 .:

  • Dit is mijn beste oplossing
  • We kunnen geen gebruik maken van DateTime.DayOfYear of TimeSpans, omdat ze verschuiven aantal dagen in schrikkeljaren
  • Ik heb daar te zetten weinig meer regels voor de leesbaarheid

Nog één opmerking ... Ik zou 2 statische overbelast methoden voor het, één voor universeel gebruik, de tweede voor het gebruik-vriendelijkheid te maken:

public static int GetAge(DateTime bithDay, DateTime today) 
{ 
  //chosen solution method body
}

public static int GetAge(DateTime birthDay) 
{ 
  return GetAge(birthDay, DateTime.Now);
}
antwoordde op 11/04/2011 om 15:47
bron van user

stemmen
42

Ik ben te laat aan de partij, maar hier is een one-liner:

int age = new DateTime(DateTime.Now.Subtract(birthday).Ticks).Year-1;
antwoordde op 18/05/2009 om 13:36
bron van user

stemmen
32

Dit is de versie die we hier gebruiken. Het werkt, en het is vrij eenvoudig. Het is hetzelfde idee als Jeff's, maar ik denk dat het een beetje duidelijker omdat het scheidt de logica voor één af te trekken, dus het is een beetje makkelijker te begrijpen.

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

Je kon de ternaire operator uit te breiden om het nog duidelijker te maken, als je denkt dat soort dingen is onduidelijk.

Uiteraard gebeurt dit als een uitbreiding methode op DateTime, maar het is duidelijk kunt u dat een regel code die het werk doet grijpen en zet het overal. Hier hebben we weer een overbelasting van de Extension methode die in gaat DateTime.Now, alleen voor de volledigheid.

antwoordde op 06/08/2008 om 11:23
bron van user

stemmen
31

Vele jaren geleden, het verschaffen van een leeftijd calculator gimmick op mijn website, schreef ik een functie om de leeftijd te berekenen tot een fractie. Dit is een snelle port van die functie tot C # (van de PHP-versie ). Ik ben bang dat ik er niet in geslaagd om de C # versie te testen, maar hopen dat u geniet allemaal hetzelfde!

(Toegegeven, dit is een beetje gimmicky in de zin van het tonen van gebruikersprofielen op stack overflow, maar misschien lezers zullen sommige gebruiken voor te vinden. :-))

double AgeDiff(DateTime date1, DateTime date2) {
    double years = date2.Year - date1.Year;

    /*
     * If date2 and date1 + round(date2 - date1) are on different sides
     * of 29 February, then our partial year is considered to have 366
     * days total, otherwise it's 365. Note that 59 is the day number
     * of 29 Feb.
     */
    double fraction = 365
            + (DateTime.IsLeapYear(date2.Year) && date2.DayOfYear >= 59
            && (date1.DayOfYear < 59 || date1.DayOfYear > date2.DayOfYear)
            ? 1 : 0);

    /*
     * The only really nontrivial case is if date1 is in a leap year,
     * and date2 is not. So let's handle the others first.
     */
    if (DateTime.IsLeapYear(date2.Year) == DateTime.IsLeapYear(date1.Year))
        return years + (date2.DayOfYear - date1.DayOfYear) / fraction;

    /*
     * If date2 is in a leap year, but date1 is not and is March or
     * beyond, shift up by a day.
     */
    if (DateTime.IsLeapYear(date2.Year)) {
        return years + (date2.DayOfYear - date1.DayOfYear
                - (date1.DayOfYear >= 59 ? 1 : 0)) / fraction;
    }

    /*
     * If date1 is not on 29 February, shift down date1 by a day if
     * March or later. Proceed normally.
     */
    if (date1.DayOfYear != 59) {
        return years + (date2.DayOfYear - date1.DayOfYear
                + (date1.DayOfYear > 59 ? 1 : 0)) / fraction;
    }

    /*
     * Okay, here date1 is on 29 February, and date2 is not on a leap
     * year. What to do now? On 28 Feb in date2's year, the ``age''
     * should be just shy of a whole number, and on 1 Mar should be
     * just over. Perhaps the easiest way is to a point halfway
     * between those two: 58.5.
     */
    return years + (date2.DayOfYear - 58.5) / fraction;
}
antwoordde op 01/08/2008 om 09:57
bron van user

stemmen
29

Ik gebruik deze:

public static class DateTimeExtensions
{
    public static int Age(this DateTime birthDate)
    {
        return Age(birthDate, DateTime.Now);
    }

    public static int Age(this DateTime birthDate, DateTime offsetDate)
    {
        int result=0;
        result = offsetDate.Year - birthDate.Year;

        if (offsetDate.DayOfYear < birthDate.DayOfYear)
        {
              result--;
        }

        return result;
    }
}
antwoordde op 17/02/2010 om 14:32
bron van user

stemmen
26

Dit geeft "meer detail" op deze vraag. Misschien is dit wat je zoekt

DateTime birth = new DateTime(1974, 8, 29);
DateTime today = DateTime.Now;
TimeSpan span = today - birth;
DateTime age = DateTime.MinValue + span;

// Make adjustment due to MinValue equalling 1/1/1
int years = age.Year - 1;
int months = age.Month - 1;
int days = age.Day - 1;

// Print out not only how many years old they are but give months and days as well
Console.Write("{0} years, {1} months, {2} days", years, months, days);
antwoordde op 20/09/2013 om 20:13
bron van user

stemmen
26

De beste manier die ik ken vanwege schrikkeljaren en alles is:

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

Ik hoop dat dit helpt.

antwoordde op 01/08/2008 om 13:07
bron van user

stemmen
22

Ik heb een SQL Server-gebruiker gedefinieerde functie om iemands leeftijd te berekenen gemaakt, gezien hun geboortedatum. Dit is handig wanneer je het nodig hebt als onderdeel van een query:

using System;
using System.Data;
using System.Data.Sql;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;

public partial class UserDefinedFunctions
{
    [SqlFunction(DataAccess = DataAccessKind.Read)]
    public static SqlInt32 CalculateAge(string strBirthDate)
    {
        DateTime dtBirthDate = new DateTime();
        dtBirthDate = Convert.ToDateTime(strBirthDate);
        DateTime dtToday = DateTime.Now;

        // get the difference in years
        int years = dtToday.Year - dtBirthDate.Year;

        // subtract another year if we're before the
        // birth day in the current year
        if (dtToday.Month < dtBirthDate.Month || (dtToday.Month == dtBirthDate.Month && dtToday.Day < dtBirthDate.Day))
            years=years-1;

        int intCustomerAge = years;
        return intCustomerAge;
    }
};
antwoordde op 23/08/2008 om 14:58
bron van user

stemmen
21

Ik heb enige tijd bezig met dit en kwam met dit om iemands leeftijd te berekenen in jaren, maanden en dagen. Ik heb getest tegen het probleem en schrikkeljaren 29 februari en het lijkt te werken, zou ik alle feedback op prijs stellen:

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++;
    }

}
antwoordde op 18/05/2009 om 12:24
bron van user

stemmen
16

Moeten we mensen beschouwen die kleiner is dan 1 jaar? als de Chinese cultuur, beschrijven we leeftijd kleine baby's als 2 maanden of 4 weken.

Hieronder is mijn implementatie, het is niet zo simpel als wat ik dacht, in het bijzonder om te gaan met datum als 2/28.

public static string HowOld(DateTime birthday, DateTime now)
{
    if (now < birthday)
        throw new ArgumentOutOfRangeException("birthday must be less than now.");

    TimeSpan diff = now - birthday;
    int diffDays = (int)diff.TotalDays;

    if (diffDays > 7)//year, month and week
    {
        int age = now.Year - birthday.Year;

        if (birthday > now.AddYears(-age))
            age--;

        if (age > 0)
        {
            return age + (age > 1 ? " years" : " year");
        }
        else
        {// month and week
            DateTime d = birthday;
            int diffMonth = 1;

            while (d.AddMonths(diffMonth) <= now)
            {
                diffMonth++;
            }

            age = diffMonth-1;

            if (age == 1 && d.Day > now.Day)
                age--;

            if (age > 0)
            {
                return age + (age > 1 ? " months" : " month");
            }
            else
            {
                age = diffDays / 7;
                return age + (age > 1 ? " weeks" : " week");
            }
        }
    }
    else if (diffDays > 0)
    {
        int age = diffDays;
        return age + (age > 1 ? " days" : " day");
    }
    else
    {
        int age = diffDays;
        return "just born";
    }
}

Deze implementatie is hieronder testgevallen doorstaan.

[TestMethod]
public void TestAge()
{
    string age = HowOld(new DateTime(2011, 1, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("1 year", age);

    age = HowOld(new DateTime(2011, 11, 30), new DateTime(2012, 11, 30));
    Assert.AreEqual("1 year", age);

    age = HowOld(new DateTime(2001, 1, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("11 years", age);

    age = HowOld(new DateTime(2012, 1, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("10 months", age);

    age = HowOld(new DateTime(2011, 12, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("11 months", age);

    age = HowOld(new DateTime(2012, 10, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("1 month", age);

    age = HowOld(new DateTime(2008, 2, 28), new DateTime(2009, 2, 28));
    Assert.AreEqual("1 year", age);

    age = HowOld(new DateTime(2008, 3, 28), new DateTime(2009, 2, 28));
    Assert.AreEqual("11 months", age);

    age = HowOld(new DateTime(2008, 3, 28), new DateTime(2009, 3, 28));
    Assert.AreEqual("1 year", age);

    age = HowOld(new DateTime(2009, 1, 28), new DateTime(2009, 2, 28));
    Assert.AreEqual("1 month", age);

    age = HowOld(new DateTime(2009, 2, 1), new DateTime(2009, 3, 1));
    Assert.AreEqual("1 month", age);

    // NOTE.
    // new DateTime(2008, 1, 31).AddMonths(1) == new DateTime(2009, 2, 28);
    // new DateTime(2008, 1, 28).AddMonths(1) == new DateTime(2009, 2, 28);
    age = HowOld(new DateTime(2009, 1, 31), new DateTime(2009, 2, 28));
    Assert.AreEqual("4 weeks", age);

    age = HowOld(new DateTime(2009, 2, 1), new DateTime(2009, 2, 28));
    Assert.AreEqual("3 weeks", age);

    age = HowOld(new DateTime(2009, 2, 1), new DateTime(2009, 3, 1));
    Assert.AreEqual("1 month", age);

    age = HowOld(new DateTime(2012, 11, 5), new DateTime(2012, 11, 30));
    Assert.AreEqual("3 weeks", age);

    age = HowOld(new DateTime(2012, 11, 1), new DateTime(2012, 11, 30));
    Assert.AreEqual("4 weeks", age);

    age = HowOld(new DateTime(2012, 11, 20), new DateTime(2012, 11, 30));
    Assert.AreEqual("1 week", age);

    age = HowOld(new DateTime(2012, 11, 25), new DateTime(2012, 11, 30));
    Assert.AreEqual("5 days", age);

    age = HowOld(new DateTime(2012, 11, 29), new DateTime(2012, 11, 30));
    Assert.AreEqual("1 day", age);

    age = HowOld(new DateTime(2012, 11, 30), new DateTime(2012, 11, 30));
    Assert.AreEqual("just born", age);

    age = HowOld(new DateTime(2000, 2, 29), new DateTime(2009, 2, 28));
    Assert.AreEqual("8 years", age);

    age = HowOld(new DateTime(2000, 2, 29), new DateTime(2009, 3, 1));
    Assert.AreEqual("9 years", age);

    Exception e = null;

    try
    {
        age = HowOld(new DateTime(2012, 12, 1), new DateTime(2012, 11, 30));
    }
    catch (ArgumentOutOfRangeException ex)
    {
        e = ex;
    }

    Assert.IsTrue(e != null);
}

Hoop dat het nuttig.

antwoordde op 30/11/2012 om 13:13
bron van user

stemmen
15
TimeSpan diff = DateTime.Now - birthdayDateTime;
string age = String.Format("{0:%y} years, {0:%M} months, {0:%d}, days old", diff);

Ik ben niet zeker hoe precies u wilt dat aan u geretourneerd, dus maakte ik gewoon een leesbare string.

antwoordde op 19/09/2013 om 16:18
bron van user

stemmen
15

De eenvoudigste manier die ik ooit heb gevonden is dit. Het werkt juist voor de VS en West-Europa locales. Kan niet naar andere locaties, met name landen als China spreken. 4 extra vergelijkt, hooguit na de eerste berekening van de leeftijd.

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 ;
}

Ik keek over de antwoorden op deze en zag dat niemand verwijzing heeft gemaakt naar de regelgeving / wettelijke implicaties van de schrikkeldag geboorten. Bijvoorbeeld, per Wikipedia , als je bent geboren op 29 februari in verschillende jurisdicties, je bent niet-schrikkeljaar verjaardag varieert:

  • In het Verenigd Koninkrijk en Hong Kong: het is de ordinale dag van het jaar, dus de volgende dag, 1 maart is je verjaardag.
  • In Nieuw-Zeeland: het is de vorige dag, 28 februari in het kader van het rijbewijs, en 1 maart voor andere doeleinden.
  • Taiwan: het is 28 februari.

En zo dicht als ik kan vertellen, in de VS, de statuten wordt niets gezegd over de zaak, waarbij het aan de common law en hoe de verschillende regelgevende instanties bepalen dingen in hun regelgeving.

Te dien einde, een verbetering:

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;
}

Opgemerkt wordt dat deze code aanneemt:

  • Een westerse (Europese) berekening van de leeftijd, en
  • Een kalender, zoals de Gregoriaanse kalender die één schrikkeldag voegt aan het einde van de maand.
antwoordde op 06/10/2010 om 02:49
bron van user

stemmen
15

Hou het simpel (en eventueel dom :)).

DateTime birth = new DateTime(1975, 09, 27, 01, 00, 00, 00);
TimeSpan ts = DateTime.Now - birth;
Console.WriteLine("You are approximately " + ts.TotalSeconds.ToString() + " seconds old.");
antwoordde op 18/08/2010 om 15:29
bron van user

stemmen
14

Dit is een van de meest nauwkeurige antwoord dat in staat is om de verjaardag van 29 februari op te lossen vergelijken met een jaar van 28 februari

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

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

    return age;
}
antwoordde op 23/10/2014 om 14:18
bron van user

stemmen
13

Hier is nog een ander antwoord:

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

Dit is uitgebreid-eenheid getest. Het ziet er een beetje "magie". Het nummer 372 is het aantal dagen zouden er in een jaar zijn als iedere maand had 31 dagen.

De verklaring voor waarom het werkt ( een dieptepass vanaf hier ) is:

Laten we stellen 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

We weten dat wat we nodig hebben is ofwel Yn-Ybals de datum al is bereikt, Yn-Yb-1als het niet.

a) Als Mn<Mb, we hebben-341 <= 31*(Mn-Mb) <= -31 and -30 <= Dn-Db <= 30

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

Met integerdeling

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

b) Indien Mn=Mben Dn<Db, we hebben31*(Mn - Mb) = 0 and -30 <= Dn-Db <= -1

Met integerdeling weer

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

c) Indien Mn>Mb, we hebben31 <= 31*(Mn-Mb) <= 341 and -30 <= Dn-Db <= 30

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

Met integerdeling

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

d) Indien Mn=Mben Dn>Db, we hebben 31*(Mn - Mb) = 0 and 1 <= Dn-Db <= 30

Met integerdeling weer

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

e) Indien Mn=Mben Dn=Db, we hebben31*(Mn - Mb) + Dn-Db = 0

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

antwoordde op 22/04/2013 om 09:19
bron van user

stemmen
13

Dit is niet een direct antwoord, maar meer van een filosofische redenering over het probleem bij de hand van een quasi-wetenschappelijk oogpunt.

Ik zou zeggen dat de vraag naar het toestel, noch cultuur waarin te meten leeftijd niet bepaalt, de meeste antwoorden lijken een integer jaarlijkse voorstelling te nemen. De SI-eenheid voor tijd second, ergo de juiste generieke antwoord zou moeten zijn (uiteraard in de veronderstelling genormaliseerd DateTimeen nemen geen aandacht dan ook tot de relativistische effecten):

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

In de christelijke manier van berekening van de leeftijd in jaren:

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 de financiële wereld is er een soortgelijk probleem bij de berekening van iets vaak aangeduid als de Day Count Fraction , die ruwweg is een aantal jaren voor een bepaalde periode. En de leeftijd kwestie is echt een tijd meten kwestie.

Voorbeeld voor de actual / actual (tellen alle dagen "correct") conventie:

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;

Een andere vrij veel voorkomende manier om de tijd in het algemeen te meten, is door "Serializing" (de kerel die naam deze datum conventie moet serieus trippin zijn geweest):

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

Ik vraag me af hoe lang we moeten gaan voor een relativistische tijd in seconden wordt nuttiger dan de ruwe benadering van de aarde-around-sun-cycli tijdens iemands leven tot nu toe :) Of met andere woorden, wanneer een periode van een locatie moet worden gegeven of een functie die ontwerp zelf geldig :)

antwoordde op 23/11/2012 om 16:00
bron van user

stemmen
13

Hier is een oplossing.

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);
antwoordde op 18/06/2009 om 11:35
bron van user

stemmen
12

Wat dacht je van deze oplossing?

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"; ;
}
antwoordde op 08/03/2011 om 08:25
bron van user

stemmen
11

Ik heb een aangepaste methode voor het berekenen van de leeftijd, plus een bonus validatie boodschap voor het geval dat het helpt:

public void GetAge(DateTime dob, DateTime now, out int years, out int months, out int days)
{
    years = 0;
    months = 0;
    days = 0;

    DateTime tmpdob = new DateTime(dob.Year, dob.Month, 1);
    DateTime tmpnow = new DateTime(now.Year, now.Month, 1);

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

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

    if (DateTime.IsLeapYear(dob.Year) && dob.Month == 2 && dob.Day == 29 && now >= new DateTime(now.Year, 3, 1))
        days++;

}   

private string ValidateDate(DateTime dob) //This method will validate the date
{
    int Years = 0; int Months = 0; int Days = 0;

    GetAge(dob, DateTime.Now, out Years, out Months, out Days);

    if (Years < 18)
        message =  Years + " is too young. Please try again on your 18th birthday.";
    else if (Years >= 65)
        message = Years + " is too old. Date of Birth must not be 65 or older.";
    else
        return null; //Denotes validation passed
}

Methode oproep hier en pass out datetime-waarde (dd / mm / yyyy als server ingesteld naar de VS locale). Vervang dit met iets van een melding, of een container worden weergegeven:

DateTime dob = DateTime.Parse("03/10/1982");  

string message = ValidateDate(dob);

lbldatemessage.Visible = !StringIsNullOrWhitespace(message);
lbldatemessage.Text = message ?? ""; //Ternary if message is null then default to empty string

Vergeet niet dat u het bericht zoals u dat wilt formatteren.

antwoordde op 22/01/2014 om 08:23
bron van user

stemmen
10
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;
}
antwoordde op 06/09/2010 om 15:09
bron van user

stemmen
8

SQL versie:

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  
antwoordde op 30/06/2016 om 11:24
bron van user

stemmen
8

Ik gebruikte oplossing ScArcher2 voor een nauwkeurige Jaar berekening van iemands leeftijd, maar ik nodig om het verder te gaan en de berekening van hun maanden en in dagen, samen met de jaren.

    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;
}
antwoordde op 12/08/2011 om 21:53
bron van user

stemmen
6

Wow, moest ik mijn commentaar geven .. Er zijn zo veel antwoorden op zo'n eenvoudige

private int CalcularIdade(DateTime dtNascimento)
    {
        var nHoje = Convert.ToInt32(DateTime.Today.ToString("yyyyMMdd"));
        var nAniversario = Convert.ToInt32(dtNascimento.ToString("yyyyMMdd"));

        double diff = (nHoje - nAniversario) / 10000;

        var ret = Convert.ToInt32(Math.Truncate(diff));

        return ret;
    }

Hoop dat iemand kan helpen, in ieder geval zal iemand denken .. :)

antwoordde op 29/09/2016 om 20:13
bron van user

stemmen
6

Dit is de makkelijkste manier om dit te beantwoorden in een enkele lijn.

DateTime Dob = DateTime.Parse("1985-04-24");

int Age = DateTime.MinValue.AddDays(DateTime.Now.Subtract(Dob).TotalHours/24).Year - 1;

Dit werkt ook voor schrikkeljaren.

antwoordde op 27/04/2016 om 14:58
bron van user

stemmen
6

De volgende aanpak (uittreksel uit Tijd Periode Library for .NET klasse DateDiff ) beschouwt de kalender van de cultuur info:

// ----------------------------------------------------------------------
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

Gebruik:

// ----------------------------------------------------------------------
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
antwoordde op 13/05/2011 om 09:12
bron van user

stemmen
5
    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
    }
antwoordde op 22/10/2016 om 19:10
bron van user

stemmen
5

=== Common Zeggen (van maanden tot jaren oud) ===

Als je gewoon voor algemeen gebruik, hier is de code als uw informatie:

DateTime today = DateTime.Today;
DateTime bday = DateTime.Parse("2016-2-14");
int age = today.Year - bday.Year;
var unit = "";

if (bday > today.AddYears(-age))
{
    age--;
}
if (age == 0)   // Under one year old
{
    age = today.Month - bday.Month;

    age = age <= 0 ? (12 + age) : age;  // The next year before birthday

    age = today.Day - bday.Day >= 0 ? age : --age;  // Before the birthday.day

    unit = "month";
}
else {
    unit = "year";
}

if (age > 1)
{
    unit = unit + "s";
}

Het testresultaat zoals hieronder:

The birthday: 2016-2-14

2016-2-15 =>  age=0, unit=month;
2016-5-13 =>  age=2, unit=months;
2016-5-14 =>  age=3, unit=months; 
2016-6-13 =>  age=3, unit=months; 
2016-6-15 =>  age=4, unit=months; 
2017-1-13 =>  age=10, unit=months; 
2017-1-14 =>  age=11, unit=months; 
2017-2-13 =>  age=11, unit=months; 
2017-2-14 =>  age=1, unit=year; 
2017-2-15 =>  age=1, unit=year; 
2017-3-13 =>  age=1, unit=year;
2018-1-13 =>  age=1, unit=year; 
2018-1-14 =>  age=1, unit=year; 
2018-2-13 =>  age=1, unit=year; 
2018-2-14 =>  age=2, unit=years; 
antwoordde op 04/05/2016 om 08:29
bron van user

stemmen
5

Dit is eenvoudig en lijkt accurater voor mijn behoeften. Ik ben het maken van een aanname voor de toepassing van schrikkeljaren dat zij ongeacht wanneer de persoon die ervoor kiest om de verjaardag te vieren zijn technisch niet een jaar ouder, tot een volledige 365 dagen is verstreken sinds er vorig verjaardag (dat wil zeggen 28 februari maakt ze niet per jaar te maken ouder)

DateTime now = DateTime.Today;
DateTime birthday = new DateTime(1991, 02, 03);//3rd feb

int age = now.Year - birthday.Year;

if (now.Month < birthday.Month || (now.Month == birthday.Month && now.Day < birthday.Day))//not had bday this year yet
  age--;

return age;

Laat ons weten of er nog problemen zijn;)

antwoordde op 24/02/2012 om 13:58
bron van user

stemmen
4

Ik heb een kleine wijziging aangebracht in Mark Soen's antwoord: Ik heb rewriten de derde lijn, zodat de expressie een beetje meer gemakkelijk kan worden ontleed.

public int AgeInYears(DateTime bday)
{
    DateTime now = DateTime.Today;
    int age = now.Year - bday.Year;            
    if (bday.AddYears(age) > now) 
        age--;
    return age;
}

Ook heb ik het in een functie voor de duidelijkheid.

antwoordde op 16/07/2011 om 19:01
bron van user

stemmen
3
public string GetAge(this DateTime birthdate, string ageStrinFormat = null)
{
    var date = DateTime.Now.AddMonths(-birthdate.Month).AddDays(-birthdate.Day);
    return string.Format(ageStrinFormat ?? "{0}/{1}/{2}",
        (date.Year - birthdate.Year), date.Month, date.Day);
}
antwoordde op 12/10/2015 om 13:12
bron van user

stemmen
3

Waarom kan het niet deze eenvoudige?

int age = DateTime.Now.AddTicks(0 - dob.Ticks).Year - 1;
antwoordde op 26/06/2015 om 16:00
bron van user

stemmen
3

Dit klassieke vraag verdient een Noda Time oplossing.

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;
}

Gebruik:

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

U bent wellicht ook geïnteresseerd in de volgende verbeteringen:

  • Passeren in de klok als een IClock, in plaats van het gebruik SystemClock.Instance, zou testbaarheid verbeteren.

  • De doelstelling tijdzone zal waarschijnlijk veranderen, zodat u een zou willen DateTimeZoneparameter ook.

Zie ook mijn blog post over dit onderwerp: Behandeling Verjaardagen, en andere Verjaardagen

antwoordde op 21/12/2013 om 05:53
bron van user

stemmen
3

Hier is een DateTime extender dat de leeftijd berekening draagt ​​bij aan de DateTime object.

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;
    }
}
antwoordde op 20/05/2011 om 17:48
bron van user

stemmen
2

Gebruik gewoon:

(DateTime.Now - myDate).TotalHours / 8766.0

de huidige datum - myDate = TimeSpan, krijgen totaal aantal uren en de kloof in het totale aantal uren per jaar en ontvang exacly de leeftijd / maanden / dagen ...

antwoordde op 15/12/2017 om 17:27
bron van user

stemmen
2

Ik reken vaak op mijn vingers. Ik moet een kalender kijken uit te werken als er dingen veranderen. Dus dat is wat ik zou doen in mijn code:

int AgeNow(DateTime birthday)
{
    return AgeAt(DateTime.Now, birthday);
}

int AgeAt(DateTime now, DateTime birthday)
{
    return AgeAt(now, birthday, CultureInfo.CurrentCulture.Calendar);
}

int AgeAt(DateTime now, DateTime birthday, Calendar calendar)
{
    // My age has increased on the morning of my 
    // birthday even though I was born in the evening.
    now = now.Date;
    birthday = birthday.Date;

    var age = 0;
    if (now <= birthday) return age; // I am zero now if I am to be born tomorrow.

    while (calendar.AddYears(birthday, age + 1) <= now)
    {
        age++;
    }
    return age;
}

Het uitvoeren van deze door middel van in LINQPad geeft dit:

PASSED: someone born on 28 February 1964 is age 4 on 28 February 1968
PASSED: someone born on 29 February 1964 is age 3 on 28 February 1968
PASSED: someone born on 31 December 2016 is age 0 on 01 January 2017

Code in LINQPad is hier

antwoordde op 16/07/2017 om 10:39
bron van user

stemmen
2

Ik heb gebruikt voor dit probleem, ik weet het, het is niet erg elegant, maar het werkt

DateTime zeroTime = new DateTime(1, 1, 1);
var date1 = new DateTime(1983, 03, 04);
var date2 = DateTime.Now;
var dif = date2 - date1;
int years = (zeroTime + dif).Year - 1;
Log.DebugFormat("Years -->{0}", years);
antwoordde op 05/10/2015 om 17:09
bron van user

stemmen
2

Hier is een functie die dienst doet me goed ... Geen calcs, zeer eenvoudig.

    public static string ToAge(this DateTime dob, DateTime? toDate = null)
    {
        if (!toDate.HasValue)
            toDate = DateTime.Now;
        var now = toDate.Value;

        if (now.CompareTo(dob) < 0)
            return "Future date";

        int years = now.Year - dob.Year;
        int months = now.Month - dob.Month;
        int days = now.Day - dob.Day;

        if (days < 0)
        {
            months--;
            days = DateTime.DaysInMonth(dob.Year, dob.Month) - dob.Day + now.Day;
        }

        if (months < 0)
        {
            years--;
            months = 12 + months;
        }


        return string.Format("{0} year(s), {1} month(s), {2} days(s)",
            years,
            months,
            days);
    }

En hier is een unit test:

    [Test]
    public void ToAgeTests()
    {
        var date = new DateTime(2000, 1, 1);
        Assert.AreEqual("0 year(s), 0 month(s), 1 days(s)", new DateTime(1999, 12, 31).ToAge(date));
        Assert.AreEqual("0 year(s), 0 month(s), 0 days(s)", new DateTime(2000, 1, 1).ToAge(date));
        Assert.AreEqual("1 year(s), 0 month(s), 0 days(s)", new DateTime(1999, 1, 1).ToAge(date));
        Assert.AreEqual("0 year(s), 11 month(s), 0 days(s)", new DateTime(1999, 2, 1).ToAge(date));
        Assert.AreEqual("0 year(s), 10 month(s), 25 days(s)", new DateTime(1999, 2, 4).ToAge(date));
        Assert.AreEqual("0 year(s), 10 month(s), 1 days(s)", new DateTime(1999, 2, 28).ToAge(date));

        date = new DateTime(2000, 2, 15);
        Assert.AreEqual("0 year(s), 0 month(s), 28 days(s)", new DateTime(2000, 1, 18).ToAge(date));
    }
antwoordde op 24/06/2015 om 11:26
bron van user

stemmen
2

Ik wil Hebrew kalenderberekeningen (of andere System.Globalization kalender kan worden gebruikt op dezelfde manier) toe, via rewrited functies van deze discussie:

Public Shared Function CalculateAge(BirthDate As DateTime) As Integer
    Dim HebCal As New System.Globalization.HebrewCalendar ()
    Dim now = DateTime.Now()
    Dim iAge = HebCal.GetYear(now) - HebCal.GetYear(BirthDate)
    Dim iNowMonth = HebCal.GetMonth(now), iBirthMonth = HebCal.GetMonth(BirthDate)
    If iNowMonth < iBirthMonth Or (iNowMonth = iBirthMonth AndAlso HebCal.GetDayOfMonth(now) < HebCal.GetDayOfMonth(BirthDate)) Then iAge -= 1
    Return iAge
End Function
antwoordde op 11/01/2012 om 09:58
bron van user

stemmen
2

Hier is een kleine code monster voor C # Ik klopte op, wees voorzichtig rondom de rand gevallen specifiek schrikkeljaren, niet alle bovenstaande oplossingen houden hiermee rekening. Duwen het antwoord als een DateTime kan problemen veroorzaken als je kon uiteindelijk probeert te veel dagen in een bepaalde maand bijvoorbeeld 30 dagen in februari zetten

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;
}
antwoordde op 18/12/2009 om 15:55
bron van user

stemmen
2

Zou dit werken?

public override bool IsValid(DateTime value)
{
    _dateOfBirth =  value;
    var yearsOld = (double) (DateTime.Now.Subtract(_dateOfBirth).TotalDays/365);
    if (yearsOld > 18)
        return true;
    return false; 
}
antwoordde op 28/11/2009 om 02:58
bron van user

stemmen
2

Ik denk dat de TimeSpan heeft alles wat we nodig hebben in het, zonder hun toevlucht nemen tot 365,25 (of een andere benadering). Als uitbreiding op bijvoorbeeld augustus's:

DateTime myBD = new DateTime(1980, 10, 10);
TimeSpan difference = DateTime.Now.Subtract(myBD);

textBox1.Text = difference.Years + " years " + difference.Months + " Months " + difference.Days + " days";
antwoordde op 26/09/2008 om 21:07
bron van user

stemmen
1
var birthDate = ... // DOB
var resultDate = DateTime.Now - birthDate;

Met behulp van resultDateu kunt toepassen TimeSpaneigenschappen wat je wilt om het te laten zien.

antwoordde op 15/02/2018 om 11:17
bron van user

stemmen
1

Hier is de eenvoudigste manier om iemands leeftijd te berekenen.
Het berekenen van iemands leeftijd is vrij eenvoudig, en hier is hoe! Om de code te werken, heb je een DateTime object met de naam BirthDate die de verjaardag nodig.

 C#
        // get the difference in years
        int years = DateTime.Now.Year - BirthDate.Year; 
        // subtract another year if we're before the
        // birth day in the current year
        if (DateTime.Now.Month < BirthDate.Month || 
            (DateTime.Now.Month == BirthDate.Month && 
            DateTime.Now.Day < BirthDate.Day)) 
            years--;
  VB.NET
        ' get the difference in years
        Dim years As Integer = DateTime.Now.Year - BirthDate.Year
        ' subtract another year if we're before the
        ' birth day in the current year
        If DateTime.Now.Month < BirthDate.Month Or (DateTime.Now.Month = BirthDate.Month And DateTime.Now.Day < BirthDate.Day) Then 
            years = years - 1
        End If
antwoordde op 08/02/2018 om 15:10
bron van user

stemmen
1

Om te berekenen hoeveel jaar een persoon is,

DateTime DateOfBirth;

int AgeInYears = DateTime.Now.Year - DateOfBirth.Year;
antwoordde op 31/10/2017 om 12:09
bron van user

stemmen
1

Simple Code

 var birthYear=1993;
 var age = DateTime.Now.AddYears(-birthYear).Year;
antwoordde op 27/10/2017 om 06:43
bron van user

stemmen
1

Ik zou dit alleen maar doen:

DateTime birthDay = new DateTime(1990, 05, 23);
DateTime age = DateTime.Now - birthDay;

Op deze manier kunt u het berekenen van de exacte leeftijd van een persoon, tot op de milliseconde als je wilt.

antwoordde op 02/07/2015 om 07:37
bron van user

stemmen
1

Gewoon omdat ik denk niet dat de top antwoord is dat duidelijk:

public static int GetAgeByLoop(DateTime birthday)
{
    var age = -1;

    for (var date = birthday; date < DateTime.Today; date = date.AddYears(1))
        age++;

    return age;
}
antwoordde op 17/02/2015 om 17:24
bron van user

stemmen
1

Hoe komt het dat MSDN hulp heb je niet vertellen dat? Het ziet er zo voor de hand liggend:

System.DateTime birthTime = AskTheUser(myUser); // :-)
System.DateTime now = System.DateTime.Now;
System.TimeSpan age = now - birthTime; //as simple as that
double ageInDays = age.TotalDays; // will you convert to whatever you want yourself?
antwoordde op 19/09/2013 om 14:15
bron van user

stemmen
1

Met minder conversies en UtcNow, kan deze code zorg voor iemand geboren op 29 februari op een schrikkeljaar te nemen:

public int GetAge(DateTime DateOfBirth)
{
    var Now = DateTime.UtcNow;
    return Now.Year - DateOfBirth.Year -
        (
            (
                Now.Month > DateOfBirth.Month ||
                (Now.Month == DateOfBirth.Month && Now.Day >= DateOfBirth.Day)
            ) ? 0 : 1
        );
}
antwoordde op 08/09/2013 om 12:01
bron van user

stemmen
1

Hier is een zeer eenvoudige en makkelijk te voorbeeld te volgen.

private int CalculateAge()
{
//get birthdate
   DateTime dtBirth = Convert.ToDateTime(BirthDatePicker.Value);
   int byear = dtBirth.Year;
   int bmonth = dtBirth.Month;
   int bday = dtBirth.Day;
   DateTime dtToday = DateTime.Now;
   int tYear = dtToday.Year;
   int tmonth = dtToday.Month;
   int tday = dtToday.Day;
   int age = tYear - byear;
   if (bmonth < tmonth)
       age--;
   else if (bmonth == tmonth && bday>tday)
   {
       age--;
   }
return age;
}
antwoordde op 02/01/2013 om 17:09
bron van user

stemmen
1

Probeer deze oplossing, het werkt.

int age = (Int32.Parse(DateTime.Today.ToString("yyyyMMdd")) - 
           Int32.Parse(birthday.ToString("yyyyMMdd rawrrr"))) / 10000;
antwoordde op 04/07/2012 om 12:28
bron van user

stemmen
1

Ik heb een leeftijd structuur, die ziet er als volgt gemaakt:

public struct Age : IEquatable<Age>, IComparable<Age>
{
    private readonly int _years;
    private readonly int _months;
    private readonly int _days;

    public int Years  { get { return _years; } }
    public int Months { get { return _months; } }
    public int Days { get { return _days; } }

    public Age( int years, int months, int days ) : this()
    {
        _years = years;
        _months = months;
        _days = days;
    }

    public static Age CalculateAge( DateTime dateOfBirth, DateTime date )
    {
        // Here is some logic that ressembles Mike's solution, although it
        // also takes into account months & days.
        // Ommitted for brevity.
        return new Age (years, months, days);
    }

    // Ommited Equality, Comparable, GetHashCode, functionality for brevity.
}
antwoordde op 16/12/2009 om 10:55
bron van user

stemmen
-1

Een een Linear antwoord,

    DateTime dateOfBirth = Convert.ToDateTime("01/16/1990");
    var age = ((DateTime.Now - dateOfBirth).Days) / 365;
antwoordde op 29/07/2014 om 12:46
bron van user

stemmen
-2

Check this out:

TimeSpan ts = DateTime.Now.Subtract(Birthdate);
age = (byte)(ts.TotalDays / 365.25);
antwoordde op 09/05/2015 om 22:03
bron van user

stemmen
-2

Om de leeftijd met dichtstbijzijnde leeftijd te berekenen:

var ts = DateTime.Now - new DateTime(1988, 3, 19);
var age = Math.Round(ts.Days / 365.0);
antwoordde op 03/12/2013 om 11:14
bron van user

stemmen
-3

Ik hou niet van veel van de antwoorden hier omdat ze een aantal regels code te nemen om te doen wat moet een zeer eenvoudige datemath berekening (gelieve te bewaren al uw opmerkingen over leeftijd berekening in andere culturen, tenzij je wilt een antwoord dat ze bedekt posten). My one liner, met behulp van eenvoudige datemath en wiskundige functies die er bestaan ​​in C #, SQL Server, MySQL, etc. is:

year(@today)-year(@birthDate)+floor((month(@today)-month(@birthdate)+floor((day(@today)-day(@birthdate))/31))/12)

Maar ik heb ook heel graag antwoord Mathew boven. Hoe dan ook is veel efficiënter dan de andere antwoorden hier gegeven.

antwoordde op 23/07/2015 om 16:03
bron van user

stemmen
-3
int age = DateTime.Now.Year - birthday.Year;
if (DateTime.Now.Month < birthday.Month || DateTime.Now.Month == birthday.Month 
&& DateTime.Now.Day < birthday.Day) age--;
antwoordde op 11/06/2014 om 12:23
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more