Come faccio a calcolare l'età di una persona in C #?

voti
1k

Data una DateTimeche rappresenta il compleanno di una persona, come faccio a calcolare la loro età in anni?

È pubblicato 01/08/2008 alle 00:40
fonte dall'utente
In altre lingue...                            


64 risposte

voti
1k

Un facile da capire e semplice soluzione.

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

Tuttavia, questo presuppone che si sta cercando il ovest idea di età e che non utilizzano Oriente resa dei conti asiatico .

Risposto il 04/08/2008 a 17:50
fonte dall'utente

voti
874

Questo è uno strano modo di farlo, ma se si formatta la data yyyymmdde sottrarre la data di nascita dalla data corrente poi cadere le ultime 4 cifre hai l'età :)

Non so C #, ma credo che questo sarà il lavoro in qualsiasi lingua.

20080814 - 19800703 = 280111 

Eliminare le ultime 4 cifre = 28.

C # Codice:

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

O in alternativa senza tutta la conversione di tipo in forma di un metodo di estensione. Controllo errori omesso:

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;
}
Risposto il 15/08/2008 a 04:47
fonte dall'utente

voti
336

Io non so come la soluzione sbagliata può essere accolto. La correttezza C # frammento è stato scritto da Michael Stum

Ecco un frammento di prova:

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

Qui si hanno i metodi:

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;
}
Risposto il 20/10/2009 a 16:07
fonte dall'utente

voti
113

Non credo che nessuna delle risposte finora prevedono culture che calcolare l'età in modo diverso. Si veda, ad esempio, orientale Età Reckoning rispetto che in Occidente.

Ogni vera risposta deve includere la localizzazione. Il modello di strategia sarebbe probabilmente in ordine in questo esempio.

Risposto il 17/08/2008 a 18:14
fonte dall'utente

voti
98

La semplice risposta a questo è quello di applicare AddYearscome illustrato di seguito, perché questo è l'unico metodo nativo per aggiungere anni alla 29 febbraio degli anni bisestili e ottenere il risultato corretto della 28 Febbraio per anni comuni.

Alcuni ritengono che 1 marzo è il compleanno di leaplings ma né .Net né alcuna regola ufficiale sostiene questo, né logica comune spiegare perché alcuni nati nel mese di febbraio dovrebbe avere il 75% dei loro compleanni in un altro mese.

Inoltre, un metodo di Age si presta ad essere aggiunto come un'estensione DateTime. Con questo è possibile ottenere l'età nel modo più semplice possibile:

  1. elemento della lista

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

Ora, eseguire questo 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();
    }
}

La data di esempio critico è questo:

Data di nascita: 2000/02/29 data successiva: 2011-02-28 Età: 11

Produzione:

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

E per la data successiva 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
}
Risposto il 20/02/2011 a 00:56
fonte dall'utente

voti
74

Il mio consiglio

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

Che sembra avere il cambio anno alla data giusta. (I SPOT testato fino a 107 anni)

Risposto il 03/10/2008 a 21:19
fonte dall'utente

voti
61

Un'altra funzione, non da me, ma ha trovato sul web e affinato un po ':

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

Solo due cose che mi vengono in mente: Che dire di persone provenienti da paesi che non usano il calendario gregoriano? DateTime.Now è nella cultura specifico del server credo. Non ho assolutamente 0 conoscenza di realtà di lavoro con i calendari asiatici e non so se c'è un modo semplice per convertire date tra calendari, ma solo nel caso in cui vi state chiedendo quei ragazzi cinesi l'anno 4660 :-)

Risposto il 01/08/2008 a 22:46
fonte dall'utente

voti
43

2 problemi principali da risolvere sono:

1. Calcolare età esatta - in anni, mesi, giorni, ecc

2. Calcolare l'età generalmente percepito - la gente di solito non importa quanti anni hanno esattamente sono, solo attenzione quando il loro compleanno l'anno in corso è.


Soluzione per 1 è evidente:

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

Soluzione 2 è quella che non è così preciso nel determinare l'età totale, ma è percepito come preciso dalla gente. La gente di solito usa, quando calcolano la loro età "manualmente":

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
}

Note per 2 .:

  • Questa è la mia soluzione preferita
  • Non possiamo usare DateTime.DayOfYear o TimeSpan, come si spostano numero di giorni negli anni bisestili
  • Ho messo lì poco più righe per facilitarne la lettura

Ancora una nota ... vorrei creare 2 metodi statici di overload per esso, uno per uso universale, secondo per l'uso-friendly:

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

public static int GetAge(DateTime birthDay) 
{ 
  return GetAge(birthDay, DateTime.Now);
}
Risposto il 11/04/2011 a 15:47
fonte dall'utente

voti
42

Sono in ritardo alla festa, ma ecco una battuta:

int age = new DateTime(DateTime.Now.Subtract(birthday).Ticks).Year-1;
Risposto il 18/05/2009 a 13:36
fonte dall'utente

voti
32

Questa è la versione che usiamo qui. Funziona, ed è abbastanza semplice. È la stessa idea Jeff ma che sia un po 'più chiaro perché separa la logica per sottrarre uno, quindi è un po' più facile da capire.

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

Si potrebbe ampliare l'operatore ternario per rendere ancora più chiaro, se si pensa che genere di cose non è chiaro.

Ovviamente questo è fatto come un metodo di estensione su DateTime, ma è chiaro che si può afferrare che una riga di codice che fa il lavoro e mettere da nessuna parte. Qui abbiamo un altro overload del metodo di estensione che passa DateTime.Now, solo per completezza.

Risposto il 06/08/2008 a 11:23
fonte dall'utente

voti
31

Molti anni fa, per fornire una calcolatrice espediente età sul mio sito, ho scritto una funzione per calcolare l'età di una frazione. Questo un breve porto di quella funzione per C # (dalla versione di PHP ). Ho paura che non ho potuto testare la versione C #, ma spero che vi piaccia lo stesso!

(Certo questo è un po 'ingannevole ai fini di mostrare i profili utente su Stack Overflow, ma forse i lettori troveranno un uso per esso. :-))

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;
}
Risposto il 01/08/2008 a 09:57
fonte dall'utente

voti
29

Io uso questo:

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;
    }
}
Risposto il 17/02/2010 a 14:32
fonte dall'utente

voti
26

Questo dà "maggiori dettagli" a questa domanda. Forse questo è quello che stai cercando

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);
Risposto il 20/09/2013 a 20:13
fonte dall'utente

voti
26

Il modo migliore che io conosca a causa di anni bisestili e tutto è:

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

Spero che questo ti aiuti.

Risposto il 01/08/2008 a 13:07
fonte dall'utente

voti
22

Ho creato uno SQL Server funzione definita utente per calcolare l'età di una persona, data la loro data di nascita. Questo è utile quando è necessario come parte di una 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;
    }
};
Risposto il 23/08/2008 a 14:58
fonte dall'utente

voti
21

Ho trascorso qualche tempo a lavorare su questo e si avvicinò con questo per calcolare l'età di qualcuno in anni, mesi e giorni. Ho testato contro il problema e anni bisestili 29 febbraio e sembra funzionare, mi farebbe piacere tutte le risposte:

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

}
Risposto il 18/05/2009 a 12:24
fonte dall'utente

voti
16

Abbiamo bisogno di prendere in considerazione le persone che è più piccolo di 1 anno? come la cultura cinese, descriviamo età bambini piccoli come 2 mesi o 4 settimane.

Qui di seguito è la mia realizzazione, non è così semplice come quello che ho immaginato, soprattutto a che fare con la data come 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";
    }
}

Questa implementazione è passata sotto casi di test.

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

La speranza è utile.

Risposto il 30/11/2012 a 13:13
fonte dall'utente

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

Non sono sicuro di come esattamente si desidera è tornato a voi, perché ho appena fatto una stringa leggibile.

Risposto il 19/09/2013 a 16:18
fonte dall'utente

voti
15

The simplest way I've ever found is this. It works correctly for the US and western europe locales. Can't speak to other locales, especially places like China. 4 extra compares, at most, following the initial computation of age.

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

Stavo guardando oltre le risposte a questo e ho notato che nessuno ha fatto riferimento alle implicazioni legali / normativi di salto nascite al giorno. Per esempio, per Wikipedia , se sei nato il 29 febbraio in varie giurisdizioni, sei non bisestile compleanno varia:

  • Nel Regno Unito e Hong Kong: è il giorno ordinale del anno, quindi il giorno successivo, 1 marzo è il tuo compleanno.
  • In Nuova Zelanda: è il giorno precedente, 28 febbraio ai fini di patenti di guida, e il 1 ° marzo per altri scopi.
  • Taiwan: è il 28 febbraio.

E il più vicino che posso dire, negli Stati Uniti, gli statuti tacciono sulla questione, lasciando al diritto comune e di come i vari organismi di regolamentazione di definire le cose nei loro regolamenti.

A tal fine, un miglioramento:

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

Va notato che questo codice comporta:

  • Un occidentale (europeo) computo dell'età, e
  • Un calendario, come il calendario gregoriano che inserisce un solo giorno salto alla fine di un mese.
Risposto il 06/10/2010 a 02:49
fonte dall'utente

voti
15

Tenendolo semplice (e forse stupido :)).

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.");
Risposto il 18/08/2010 a 15:29
fonte dall'utente

voti
14

Questo è uno dei la risposta più precisa che è in grado di risolvere il compleanno di 29 Febbraio confrontare a qualsiasi anno di 28 febbraio

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

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

    return age;
}
Risposto il 23/10/2014 a 14:18
fonte dall'utente

voti
13

Ecco l'ennesima risposta:

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

Questo è stato ampiamente unità testata. Esso ha un aspetto un po ' "magica". Il numero 372 è il numero di giorni ci sarebbe in un anno se ogni mese ha avuto 31 giorni.

La spiegazione del motivo per cui lavora ( sollevato da qui ) è il seguente:

Fissiamo 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

Sappiamo che cosa abbiamo bisogno è o Yn-Ybse è già stato raggiunto la data, Yn-Yb-1se non ha.

a) Se Mn<Mb, abbiamo-341 <= 31*(Mn-Mb) <= -31 and -30 <= Dn-Db <= 30

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

Con divisione intera

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

b) Se Mn=Mbe Dn<Db, abbiamo31*(Mn - Mb) = 0 and -30 <= Dn-Db <= -1

Con divisione intera, nuovamente

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

c) Se Mn>Mb, abbiamo31 <= 31*(Mn-Mb) <= 341 and -30 <= Dn-Db <= 30

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

Con divisione intera

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

d) Se Mn=Mbe Dn>Db, abbiamo 31*(Mn - Mb) = 0 and 1 <= Dn-Db <= 30

Con divisione intera, nuovamente

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

e) Se Mn=Mbe Dn=Db, abbiamo31*(Mn - Mb) + Dn-Db = 0

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

Risposto il 22/04/2013 a 09:19
fonte dall'utente

voti
13

Questa non è una risposta diretta, ma più di un ragionamento filosofico sul problema a portata di mano da un punto quasi-di vista scientifico.

Direi che la questione non specifica l'unità né cultura in cui misurare l'età, la maggior parte delle risposte sembrano assumere una rappresentazione annuale intero. Il SI-unità per volta è second, ergo la risposta corretta generico dovrebbe essere (ovviamente assumendo normalizzato DateTimee tenuto alcun riguardo di sorta per effetti relativistici):

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

Nel modo cristiano di calcolare l'età in anni:

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 finanza c'è un problema simile quando si calcola qualcosa spesso definito come la Frazione di Conteggio dei Giorni , che più o meno è un certo numero di anni per un determinato periodo. E la questione età è davvero un problema di misurazione del tempo.

Esempio del (contando tutti giorni "corretta") convenzione actual / actual:

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;

Un altro modo abbastanza comune per misurare il tempo in generale è di "serializzazione" (il tizio che ha chiamato questa data convenzione deve seriamente essere Trippin'):

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

Mi chiedo quanto tempo dobbiamo andare prima di un età relativistica in pochi secondi diventa più utile rispetto alla approssimazione di terra-around-sole-cicli durante la propria vita finora :) O in altre parole, quando un periodo deve essere data una località o una funzione rappresentante proposta sé sia ​​valida :)

Risposto il 23/11/2012 a 16:00
fonte dall'utente

voti
13

Ecco una soluzione.

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);
Risposto il 18/06/2009 a 11:35
fonte dall'utente

voti
12

Che ne dite di questa soluzione?

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"; ;
}
Risposto il 08/03/2011 a 08:25
fonte dall'utente

voti
11

Ho un metodo personalizzato per calcolare l'età, oltre a un messaggio di convalida bonus solo nel caso in cui esso aiuta:

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
}

chiamata di metodo qui e passare fuori valore datetime (MM / GG / se il server insieme a USA locale). Sostituire questo con tutto ciò che un MessageBox o di qualsiasi contenitore per visualizzare:

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

Ricorda che puoi formattare il messaggio come più ti piace.

Risposto il 22/01/2014 a 08:23
fonte dall'utente

voti
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;
}
Risposto il 06/09/2010 a 15:09
fonte dall'utente

voti
8

versione di SQL:

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  
Risposto il 30/06/2016 a 11:24
fonte dall'utente

voti
8

Ho usato la soluzione di ScArcher2 per un accurato calcolo Anno di un'età persone, ma avevo bisogno di prendere ulteriormente e calcolare i loro mesi e giorni insieme con gli anni.

    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;
}
Risposto il 12/08/2011 a 21:53
fonte dall'utente

voti
6

Wow, ho dovuto dare il mio commento qui .. Ci sono così tante risposte per tale un semplice

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

Spero che possa aiutare qualcuno, almeno qualcuno farà pensare .. :)

Risposto il 29/09/2016 a 20:13
fonte dall'utente

voti
6

Questo è il modo più semplice per rispondere a questa in una sola riga.

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

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

Questo funziona anche per gli anni bisestili.

Risposto il 27/04/2016 a 14:58
fonte dall'utente

voti
6

Il seguente approccio (estratto Periodo Library for .NET classe DateDiff ) considera il calendario delle informazioni della cultura:

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

Uso:

// ----------------------------------------------------------------------
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
Risposto il 13/05/2011 a 09:12
fonte dall'utente

voti
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
    }
Risposto il 22/10/2016 a 19:10
fonte dall'utente

voti
5

=== detto comune (da mesi a anni) ===

Se solo per uso comune, ecco il codice come le informazioni:

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

Il risultato del test come di seguito:

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; 
Risposto il 04/05/2016 a 08:29
fonte dall'utente

voti
5

Questo è semplice e sembra essere accurata per le mie esigenze. Sto facendo un presupposto ai fini di anni bisestili che, indipendentemente da quando la persona sceglie per festeggiare il compleanno non sono tecnicamente un anno in più fino a quando un pieno 365 giorni è passato da quando ci ultimo compleanno (vale a dire 28 febbraio non li un anno fa più vecchio)

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;

Fateci sapere se riuscite ad individuare alcuni problemi;)

Risposto il 24/02/2012 a 13:58
fonte dall'utente

voti
4

Ho fatto una piccola modifica al di Mark Soen risposta: Ho rewriten la terza linea in modo che l'espressione può essere analizzato un po 'più facilmente.

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

Ho anche fatto in una funzione per motivi di chiarezza.

Risposto il 16/07/2011 a 19:01
fonte dall'utente

voti
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);
}
Risposto il 12/10/2015 a 13:12
fonte dall'utente

voti
3

Perché non può essere così semplice?

int age = DateTime.Now.AddTicks(0 - dob.Ticks).Year - 1;
Risposto il 26/06/2015 a 16:00
fonte dall'utente

voti
3

Questa domanda classica è meritevole di un Noda Tempo soluzione.

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

Uso:

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

Potreste anche essere interessati ai seguenti miglioramenti:

  • Passando l'orologio come IClock, invece di utilizzare SystemClock.Instance, migliorerebbe verificabilità.

  • Il fuso orario di destinazione probabilmente cambierà, in modo che ci si vuole un DateTimeZoneparametro.

Vedi anche il mio blog post su questo argomento: compleanni manipolazione, e altre ricorrenze

Risposto il 21/12/2013 a 05:53
fonte dall'utente

voti
3

Ecco un extender DateTime che aggiunge il calcolo dell'età all'oggetto 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;
    }
}
Risposto il 20/05/2011 a 17:48
fonte dall'utente

voti
2

Basta usare:

(DateTime.Now - myDate).TotalHours / 8766.0

la data corrente - myDate = TimeSpan, ottenere ore totali e divide nelle ore totali annue e ottenere exacly le età / mesi / giorni ...

Risposto il 15/12/2017 a 17:27
fonte dall'utente

voti
2

Mi capita spesso di contare sulle dita. Ho bisogno di guardare un calendario per capire quando le cose cambiano. Ecco, questo è quello che farei nel mio codice:

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

L'esecuzione di questo attraverso LINQPad dà questo:

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

Codice in LINQPad è qui

Risposto il 16/07/2017 a 10:39
fonte dall'utente

voti
2

Ho usato per questo problema, lo so, non è molto elegante, ma sta funzionando

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);
Risposto il 05/10/2015 a 17:09
fonte dall'utente

voti
2

Qui è una funzione che mi sta servendo bene ... Nessun Calcoli, molto semplice.

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

E qui è un test di unità:

    [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));
    }
Risposto il 24/06/2015 a 11:26
fonte dall'utente

voti
2

Voglio aggiungere ebraico calcoli di calendario (o altro calendario System.Globalization può essere utilizzato allo stesso modo), utilizzando le funzioni riscritto da questa discussione:

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
Risposto il 11/01/2012 a 09:58
fonte dall'utente

voti
2

Ecco un esempio di codice po 'per C # ho bussato up, fare attenzione intorno ai casi limite specificamente anni bisestili, non tutte le soluzioni di cui sopra li tengono in considerazione. Spingendo la risposta come un DateTime può causare problemi, come si potrebbe finire per cercare di mettere troppi giorni in un mese specifico per esempio 30 giorni in febbraio

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;
}
Risposto il 18/12/2009 a 15:55
fonte dall'utente

voti
2

Sarebbe questo lavoro?

public override bool IsValid(DateTime value)
{
    _dateOfBirth =  value;
    var yearsOld = (double) (DateTime.Now.Subtract(_dateOfBirth).TotalDays/365);
    if (yearsOld > 18)
        return true;
    return false; 
}
Risposto il 28/11/2009 a 02:58
fonte dall'utente

voti
2

Penso che il TimeSpan ha tutto quello di cui abbiamo bisogno, senza dover ricorrere a 365,25 (o di qualsiasi altra approssimazione). Ampliando l'esempio di agosto:

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

textBox1.Text = difference.Years + " years " + difference.Months + " Months " + difference.Days + " days";
Risposto il 26/09/2008 a 21:07
fonte dall'utente

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

Utilizzando resultDateè possibile applicare TimeSpanle proprietà quello che volete per visualizzarlo.

Risposto il 15/02/2018 a 11:17
fonte dall'utente

voti
1

Ecco il modo più semplice per calcolare l'età di una persona.
Calcolo l'età di una persona è piuttosto semplice, ed ecco come! Affinché il codice per lavorare, è necessario un oggetto DateTime chiamato BirthDate contenente il compleanno.

 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
Risposto il 08/02/2018 a 15:10
fonte dall'utente

voti
1

Per calcolare quanti anni una persona è,

DateTime DateOfBirth;

int AgeInYears = DateTime.Now.Year - DateOfBirth.Year;
Risposto il 31/10/2017 a 12:09
fonte dall'utente

voti
1

Codice semplice

 var birthYear=1993;
 var age = DateTime.Now.AddYears(-birthYear).Year;
Risposto il 27/10/2017 a 06:43
fonte dall'utente

voti
1

Vorrei semplicemente fare questo:

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

In questo modo si può calcolare l'età esatta di una persona, fino al millisecondo, se si desidera.

Risposto il 02/07/2015 a 07:37
fonte dall'utente

voti
1

Solo perché non credo che la risposta superiore è chiaro:

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

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

    return age;
}
Risposto il 17/02/2015 a 17:24
fonte dall'utente

voti
1

Come mai l'aiuto di MSDN non ti ha detto questo? Sembra così ovvio:

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?
Risposto il 19/09/2013 a 14:15
fonte dall'utente

voti
1

Con meno conversioni e utcnow, questo codice può prendersi cura di qualcuno nato il 29 febbraio in un anno bisestile:

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
        );
}
Risposto il 08/09/2013 a 12:01
fonte dall'utente

voti
1

Qui è molto semplice e facile da seguire l'esempio.

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;
}
Risposto il 02/01/2013 a 17:09
fonte dall'utente

voti
1

Provare questa soluzione, che sta funzionando.

int age = (Int32.Parse(DateTime.Today.ToString("yyyyMMdd")) - 
           Int32.Parse(birthday.ToString("yyyyMMdd rawrrr"))) / 10000;
Risposto il 04/07/2012 a 12:28
fonte dall'utente

voti
1

Ho creato una struct Età, che assomiglia a questo:

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.
}
Risposto il 16/12/2009 a 10:55
fonte dall'utente

voti
-1

Una sola risposta lineare,

    DateTime dateOfBirth = Convert.ToDateTime("01/16/1990");
    var age = ((DateTime.Now - dateOfBirth).Days) / 365;
Risposto il 29/07/2014 a 12:46
fonte dall'utente

voti
-2

Controllalo:

TimeSpan ts = DateTime.Now.Subtract(Birthdate);
age = (byte)(ts.TotalDays / 365.25);
Risposto il 09/05/2015 a 22:03
fonte dall'utente

voti
-2

Per calcolare l'età con l'età più vicino:

var ts = DateTime.Now - new DateTime(1988, 3, 19);
var age = Math.Round(ts.Days / 365.0);
Risposto il 03/12/2013 a 11:14
fonte dall'utente

voti
-3

Non mi piacciono molte delle risposte qui perché prendono diverse righe di codice per fare quello che dovrebbe essere un semplice calcolo datemath (si prega di salvare tutti i vostri commenti su calcolo dell'età in altre culture se non si desidera inviare una risposta che li ricopre). Il mio uno di linea, utilizzando semplici funzioni datemath e matematiche che esistono in C #, SQLServer, MySQL, ecc è:

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

Ma mi piacciono molto anche la risposta di Mathew sopra. In entrambi i casi è molto più efficiente rispetto alle altre risposte qui riportati.

Risposto il 23/07/2015 a 16:03
fonte dall'utente

voti
-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--;
Risposto il 11/06/2014 a 12:23
fonte dall'utente

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