Aquí podría ser tu PUBLICIDAD


¿Cómo calculo la edad de alguien en C #?

votos
1745

Dado que DateTimerepresenta el cumpleaños de una persona, ¿cómo puedo calcular su edad en años?

Publicado el 01/08/2008 a las 00:40
fuente por usuario Jeff Atwood
En otros idiomas...        العربية       

64 respuestas

votos
1667

Una solución fácil de entender y simple.

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

Sin embargo, esto supone que está buscando la idea occidental de la edad y no está utilizando el cálculo del este asiático .

Respondida el 04/08/2008 a las 05:50
fuente por usuario Mike Polen


Aquí podría ser tu PUBLICIDAD


votos
874

Esta es una forma extraña de hacerlo, pero si formatea la fecha yyyymmddy resta la fecha de nacimiento de la fecha actual, entonces suelte los últimos 4 dígitos que tiene la edad :)

No sé C #, pero creo que esto funcionará en cualquier idioma.

20080814 - 19800703 = 280111 

Suelta los últimos 4 dígitos = 28.

C # Code:

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

O alternativamente sin toda la conversión de tipo en la forma de un método de extensión. Error al verificar omitido:

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;
}
Respondida el 15/08/2008 a las 04:47
fuente por usuario ScArcher2

votos
336

No sé cómo se puede aceptar la solución incorrecta. El fragmento de C # correcto fue escrito por Michael Stum

Aquí hay un fragmento de prueba:

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

Aquí tienes los métodos:

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;
}
Respondida el 20/10/2009 a las 04:07
fuente por usuario RMA

votos
113

No creo que ninguna de las respuestas proporcione culturas que calculen la edad de manera diferente. Ver, por ejemplo, el cálculo de la edad del este asiático versus el de occidente.

Cualquier respuesta real debe incluir localización. El Patrón de Estrategia probablemente estaría en orden en este ejemplo.

Respondida el 17/08/2008 a las 06:14
fuente por usuario James A. Rosen

votos
98

La respuesta simple a esto es aplicar AddYearscomo se muestra a continuación, porque este es el único método nativo para añadir años al 29 de febrero de los años bisiestos y obtener el resultado correcto del 28 de febrero por años comunes.

Algunos piensan que 1Th del Mar. Además, hay el cumpleaños de leaplings pero tampoco .Net ni ninguna norma oficial apoya esto, ni explicar la lógica común por la cual algunos nacidos en febrero debería tener el 75% de sus cumpleaños en un mes más.

Además, un método de Edad se presta a ser añadido como una extensión a DateTime. Por ello se puede obtener la edad de la manera más sencilla posible:

  1. elemento de la lista

edad int = 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;
    }
}

Ahora, ejecutar esta prueba:

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

El ejemplo crítico fecha es la siguiente:

Fecha de nacimiento: 29/02/2000 fecha posterior: 2011-02-28 Edad: 11

Salida:

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

Y para la última fecha 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
}
Respondida el 20/02/2011 a las 12:56
fuente por usuario camelCasus

votos
74

Mi sugerencia

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

Parece que el año está cambiando en la fecha correcta. (Hice la prueba hasta la edad de 107)

Respondida el 03/10/2008 a las 09:19
fuente por usuario James Curran

votos
61

Otra función, no por mí, pero que se encuentra en la web y la refinó un poco:

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 me vienen a la mente dos cosas: ¿qué hay de las personas de países que no usan el calendario gregoriano? DateTime.Now está en la cultura específica del servidor, creo. Tengo absolutamente 0 conocimiento sobre el hecho de trabajar con calendarios asiáticos y no sé si hay una manera fácil de convertir fechas entre calendarios, pero por si acaso te estás preguntando sobre esos chicos chinos del año 4660 :-)

Respondida el 01/08/2008 a las 10:46
fuente por usuario Michael Stum

votos
43

2 Los principales problemas a resolver son:

1. Calcular la edad exacta - en años, meses, días, etc.

2. Calcular la edad percibe en general - la gente por lo general no les importa la edad que son exactamente, que sólo se preocupan cuando su cumpleaños en el año actual.


Solución para 1 es obvia:

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

Solución para 2 es el que no es tan preciso en determing edad total, pero se percibe como precisa por la gente. Las personas también suelen utilizar que, cuando calculan su edad "manual":

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
}

Notas a 2 .:

  • Esta es mi solución preferida
  • No podemos utilizar DateTime.DayOfYear o periodos de tiempo, a medida que cambian el número de días en los años bisiestos
  • He puesto allí poco más líneas para facilitar la lectura

Sólo una nota más ... me gustaría crear 2 métodos sobrecargados estáticas para que, una para el uso universal, la segunda para el uso de uso:

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

public static int GetAge(DateTime birthDay) 
{ 
  return GetAge(birthDay, DateTime.Now);
}
Respondida el 11/04/2011 a las 03:47
fuente por usuario Thetam

votos
42

Llego tarde a la fiesta, pero aquí hay una sola frase:

int age = new DateTime(DateTime.Now.Subtract(birthday).Ticks).Year-1;
Respondida el 18/05/2009 a las 01:36
fuente por usuario SillyMonkey

votos
32

Esta es la versión que usamos aquí. Funciona, y es bastante simple. Es la misma idea que la de Jeff, pero creo que es un poco más clara porque separa la lógica para restar una, por lo que es un poco más fácil de entender.

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

Podría expandir el operador ternario para hacerlo aún más claro, si cree que ese tipo de cosas no está claro.

Obviamente, esto se hace como un método de extensión DateTime, pero es evidente que puede tomar esa línea de código que hace el trabajo y ponerlo en cualquier lugar. Aquí tenemos otra sobrecarga del método de extensión que ingresa DateTime.Now, solo para completar.

Respondida el 06/08/2008 a las 11:23
fuente por usuario David Wengier

votos
31

Hace muchos años, para proporcionar un truco de calculadora de edad en mi sitio web, escribí una función para calcular la edad en una fracción. Este es un puerto rápido de esa función para C # (de la versión de PHP ). Me temo que no he podido probar la versión de C #, ¡pero espero que disfrutes de todos modos!

(Es cierto que esto es un poco artificioso a los efectos de mostrar los perfiles de usuario en Stack Overflow, pero tal vez los lectores encuentren algún uso para él. :-))

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;
}
Respondida el 01/08/2008 a las 09:57
fuente por usuario Chris Jester-Young

votos
29

Yo uso esto:

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;
    }
}
Respondida el 17/02/2010 a las 02:32
fuente por usuario Elmer

votos
26

Esto da "más detalles" a esta pregunta. Tal vez esto es lo que estás buscando

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);
Respondida el 20/09/2013 a las 08:13
fuente por usuario Jacqueline Loriault

votos
26

La mejor manera que conozco debido a los años bisiestos y todo es:

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

Espero que esto ayude.

Respondida el 01/08/2008 a las 01:07
fuente por usuario Nick Berardi

votos
22

Creé una función definida por el usuario de SQL Server para calcular la edad de alguien, dada su fecha de nacimiento. Esto es útil cuando lo necesita como parte de una consulta:

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;
    }
};
Respondida el 23/08/2008 a las 02:58
fuente por usuario user2601

votos
21

He pasado un tiempo trabajando en esto y se me ocurrió esto para calcular la edad de alguien en años, meses y días. Probé contra el problema del 29 de febrero y saltamos años y parece funcionar, agradecería cualquier comentario:

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

}
Respondida el 18/05/2009 a las 12:24
fuente por usuario Jon

votos
16

¿Necesitamos tener en cuenta la gente que es menor de 1 año? como la cultura china, se describe la edad los bebés pequeños como 2 meses o 4 semanas.

A continuación es mi aplicación, no es tan simple como lo que me imaginaba, especialmente para hacer frente a la fecha como 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";
    }
}

Esta aplicación ha pasado por debajo de casos de prueba.

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

Esperamos que sea útil.

Respondida el 30/11/2012 a las 01:13
fuente por usuario rockXrock

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

No estoy seguro exactamente cómo desea que regresó a usted, por lo que acabo de hacer una cadena legible.

Respondida el 19/09/2013 a las 04:18
fuente por usuario Dakotah Hicock

votos
15

La forma más sencilla que he encontrado es esto. Funciona correctamente para las localizaciones Europa Occidental y los Estados Unidos. No se puede hablar con otros lugares, especialmente los lugares como China. 4 compara adicional, como máximo, después del cálculo inicial de edad.

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

Yo estaba buscando sobre las respuestas a esta y se dio cuenta de que nadie ha hecho referencia a las implicaciones legales / reglamentarias de nacimientos día bisiesto. Por ejemplo, por Wikipedia , si lo que se nace el 29 de febrero en varias jurisdicciones, estás no bisiesto año del cumpleaños varía:

  • En el Reino Unido y Hong Kong: es el día ordinal del año, por lo que el día siguiente, 1 de marzo es su cumpleaños.
  • En Nueva Zelanda: es el día anterior, 28 de febrero a los efectos de los permisos de conducción, y el 1 de marzo por otros fines.
  • Taiwán: es 28 de febrero.

Y lo más cerca que puedo decir, en los EE.UU., los estatutos no dicen nada sobre el asunto, dejando a la ley común y de cómo los diversos organismos reguladores definen las cosas en su normativa.

A tal efecto, una mejora:

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

Cabe señalar que este código se supone:

  • A (Europea) cómputo occidental de edad, y
  • Un calendario, al igual que el calendario gregoriano que inserta un solo día de salto al final de un mes.
Respondida el 06/10/2010 a las 02:49
fuente por usuario Nicholas Carey

votos
15

Hacer que sea sencillo (y posiblemente estúpida :)).

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.");
Respondida el 18/08/2010 a las 03:29
fuente por usuario Freddy

votos
14

Esta es una de la respuesta más precisa que es capaz de resolver el cumpleaños del 29 de Feb comparar a cualquier año del 28 de febrero

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

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

    return age;
}
Respondida el 23/10/2014 a las 02:18
fuente por usuario mjb

votos
13

Aquí tenemos otra respuesta:

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

Esto ha sido ampliamente unidad probada. Que tiene un aspecto un "mágica" bits. El número 372 es el número de días allí sería en un año si todos los meses tenían 31 días.

La explicación de por qué funciona ( levantado de aquí ) es:

Vamos a establecer 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

Sabemos que lo que necesitamos es o bien Yn-Ybsi ya se ha alcanzado la fecha, Yn-Yb-1si no lo ha hecho.

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

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

Con la división de enteros

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

b) Si Mn=Mby Dn<Db, tenemos31*(Mn - Mb) = 0 and -30 <= Dn-Db <= -1

Con la división de enteros, de nuevo

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

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

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

Con la división de enteros

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

d) Si Mn=Mby Dn>Db, tenemos 31*(Mn - Mb) = 0 and 1 <= Dn-Db <= 30

Con la división de enteros, de nuevo

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

e) Si Mn=Mby Dn=Db, tenemos31*(Mn - Mb) + Dn-Db = 0

y por lo tanto (31*(Mn - Mb) + (Dn - Db)) / 372 = 0

Respondida el 22/04/2013 a las 09:19
fuente por usuario Matthew Watson

votos
13

Esto no es una respuesta directa, pero más de un razonamiento filosófico sobre el problema en cuestión desde un punto de vista cuasi-científica.

Yo diría que la cuestión no especifica la unidad ni la cultura en la cual medir la edad, la mayoría de las respuestas parecen asumir una representación anual entero. El SI-unidad de tiempo está second, ergo la respuesta genérica correcta debería ser (por supuesto suponiendo normalizada DateTimey sin tomar en cuenta en absoluto a los efectos relativistas):

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

En el camino cristiano de calcular la edad en años:

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

En las finanzas hay un problema similar al calcular algo que a menudo se refiere como la Fracción Cuenta de días , más o menos, que es un número de años para un período determinado. Y el tema de la edad es realmente un problema de medir el tiempo.

Ejemplo para el (contando todos los días "correctamente") convención real / real:

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;

Otra forma muy común para medir el tiempo es generalmente por "serialización" (el tipo que llamó a esta convención para fechas serio debe haber sido Trippin'):

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

Me pregunto cuánto tiempo tenemos que recorrer antes de una edad relativista en cuestión de segundos se vuelve más útil que la aproximación de la tierra-alrededor-sol-ciclos durante la vida hasta el momento :) O en otras palabras, cuando un período se debe dar una ubicación o una función que representa el movimiento por sí mismo sea válido :)

Respondida el 23/11/2012 a las 04:00
fuente por usuario flindeberg

votos
13

Aquí hay una solución.

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);
Respondida el 18/06/2009 a las 11:35
fuente por usuario Rajeshwaran S P

votos
12

¿Qué hay de esta solución?

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"; ;
}
Respondida el 08/03/2011 a las 08:25
fuente por usuario Doron

votos
11

Tengo un método personalizado para calcular la edad, además de un mensaje de validación de bonificación en caso de que ayuda a:

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
}

llamada al método aquí y desmayar valor datetime (MM / dd / aaaa si está configurado el servidor de EE.UU. local). Reemplazar esta con todo un cuadro de mensaje o de cualquier contenedor para mostrar:

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

Recuerde que usted puede dar formato al mensaje de la forma que desee.

Respondida el 22/01/2014 a las 08:23
fuente por usuario DareDevil

votos
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;
}
Respondida el 06/09/2010 a las 03:09
fuente por usuario AEMLoviji

votos
8

versión de 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  
Respondida el 30/06/2016 a las 08:24
fuente por usuario xenedia

votos
8

Solía ​​solución de ScArcher2 para un cálculo preciso de Año una edad personas, pero que tenía que ir más lejos y calcular sus meses y los días, junto con los años.

    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;
}
Respondida el 12/08/2011 a las 09:53
fuente por usuario Dylan Hayes

votos
6

Wow, tuve que dar mi comentario aquí .. Hay tantas respuestas para tal un simple

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

Espero que pueda ayudar a alguien, por lo menos hará que alguien piensa .. :)

Respondida el 29/09/2016 a las 05:13
fuente por usuario André Sobreiro

votos
6

Esta es la forma más fácil de responder a esta en una sola línea.

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

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

Esto también funciona para los años bisiestos.

Respondida el 27/04/2016 a las 11:58
fuente por usuario CathalMF

votos
6

El siguiente enfoque (extracto de la biblioteca en tiempo Período de .NET clase DifFecha ) considera que el calendario de la información cultural:

// ----------------------------------------------------------------------
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
Respondida el 13/05/2011 a las 09:12
fuente por usuario user687474

votos
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
    }
Respondida el 22/10/2016 a las 04:10
fuente por usuario K1laba

votos
5

=== dicho común (de meses a años) ===

Si sólo para uso común, aquí está el código como su información:

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

El resultado de la prueba de la siguiente manera:

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; 
Respondida el 04/05/2016 a las 05:29
fuente por usuario John_J

votos
5

Esto es simple y parece ser precisa para mis necesidades. Estoy haciendo una suposición para los fines de los años bisiestos que, independientemente de que la persona elige para celebrar el cumpleaños que no son técnicamente un año más, hasta un total de 365 días transcurrido desde allí la última fecha de nacimiento (es decir, 28va de febrero de no los hace un año mayor)

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;

Háganos saber si ve ningún problema;)

Respondida el 24/02/2012 a las 01:58
fuente por usuario musefan

votos
4

He hecho un pequeño cambio a Mark Soen respuesta: He regrabadas la tercera línea, de modo que la expresión se puede analizar un poco más fácil.

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

También he hecho en una función en aras de la claridad.

Respondida el 16/07/2011 a las 07:01
fuente por usuario cdiggins

votos
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);
}
Respondida el 12/10/2015 a las 10:12
fuente por usuario Ahmed Sabry

votos
3

Por qué no puede ser tan simple?

int age = DateTime.Now.AddTicks(0 - dob.Ticks).Year - 1;
Respondida el 26/06/2015 a las 04:00
fuente por usuario Lukas

votos
3

Esta pregunta clásica es merecedor de un Noda Tiempo solución.

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

Usted también puede estar interesado en las siguientes mejoras:

  • Al pasar por el reloj como IClock, en lugar de utilizar SystemClock.Instance, mejoraría la capacidad de prueba.

  • La zona horaria de destino es probable que cambie, por lo que querrías un DateTimeZoneparámetro también.

Véase también mi blog sobre este tema: Cumpleaños manipulación, y otros aniversarios

Respondida el 21/12/2013 a las 05:53
fuente por usuario Matt Johnson

votos
3

Aquí está un extensor de DateTime que se suma el cálculo de la edad al objeto 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;
    }
}
Respondida el 20/05/2011 a las 05:48
fuente por usuario B2K

votos
2

Solo usa:

(DateTime.Now - myDate).TotalHours / 8766.0

la fecha actual - myDate = TimeSpan, obtener el total de horas y se divide en el total de horas por año y obtener exacly las edades / mes / día ...

Respondida el 15/12/2017 a las 02:27
fuente por usuario Moises Conejo

votos
2

A menudo contar con mis dedos. Tengo que mirar un calendario para trabajar cuando las cosas cambian. Así que eso es lo que haría en mi código:

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

La ejecución de este a través de LINQPad da esto:

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

Código de LINQPad es aquí

Respondida el 16/07/2017 a las 07:39
fuente por usuario Sean Kearon

votos
2

He utilizado para este problema, lo sé, no es muy elegante, pero se está trabajando

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);
Respondida el 05/10/2015 a las 02:09
fuente por usuario VhsPiceros

votos
2

Aquí es una función que me está sacando bien ... No hay calculadoras, muy simple.

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

Y aquí es una prueba de unidad:

    [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));
    }
Respondida el 24/06/2015 a las 11:26
fuente por usuario user1210708

votos
2

Quiero añadir cálculos del calendario hebreo (o otro calendario System.Globalization se puede utilizar de la misma manera), usando funciones reescrito de este tema:

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
Respondida el 11/01/2012 a las 09:58
fuente por usuario Moshe L

votos
2

He aquí un pequeño ejemplo de código para C # Me golpeado para arriba, tenga cuidado en torno a los casos extremos específicamente años bisiestos, no todas las soluciones anteriores los toman en cuenta. Empujar la respuesta como un DateTime puede causar problemas a medida que podría terminar tratando de poner demasiadas días en un mes, por ejemplo, específica de 30 días en febrero de

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;
}
Respondida el 18/12/2009 a las 03:55
fuente por usuario Jon

votos
2

¿Esto funcionaría?

public override bool IsValid(DateTime value)
{
    _dateOfBirth =  value;
    var yearsOld = (double) (DateTime.Now.Subtract(_dateOfBirth).TotalDays/365);
    if (yearsOld > 18)
        return true;
    return false; 
}
Respondida el 28/11/2009 a las 02:58
fuente por usuario azamsharp

votos
2

Creo que TimeSpan tiene todo lo que necesitamos en él, sin tener que recurrir a 365.25 (o cualquier otra aproximación). Ampliando el ejemplo de Aug:

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

textBox1.Text = difference.Years + " years " + difference.Months + " Months " + difference.Days + " days";
Respondida el 26/09/2008 a las 09:07
fuente por usuario BigJim

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

El uso resultDatese puede aplicar TimeSpanpropiedades lo que desea que aparezca.

Respondida el 15/02/2018 a las 08:17
fuente por usuario Jagdish

votos
1

Esta es la forma más sencilla de calcular la edad de una persona.
Calcular la edad de una persona es bastante sencillo, y aquí es cómo! Para que el código funcione, se necesita un objeto DateTime denominado BirthDate que contiene el cumpleaños.

 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
Respondida el 08/02/2018 a las 12:10
fuente por usuario wild coder

votos
1

Para calcular el número de años que una persona es,

DateTime DateOfBirth;

int AgeInYears = DateTime.Now.Year - DateOfBirth.Year;
Respondida el 31/10/2017 a las 09:09
fuente por usuario Kaval Patel

votos
1

Código sencilla

 var birthYear=1993;
 var age = DateTime.Now.AddYears(-birthYear).Year;
Respondida el 27/10/2017 a las 03:43
fuente por usuario Sunny Jangid

votos
1

Me limitaré a hacer esto:

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

De esta manera se puede calcular la edad exacta de una persona, hasta la milésima de segundo, si quieres.

Respondida el 02/07/2015 a las 07:37
fuente por usuario BrunoVT

votos
1

El hecho de que no creo que la respuesta más común es que claro:

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

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

    return age;
}
Respondida el 17/02/2015 a las 05:24
fuente por usuario dav_i

votos
1

¿Cómo es que la ayuda de MSDN no te dijo eso? Parece tan obvio:

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?
Respondida el 19/09/2013 a las 02:15
fuente por usuario Archit

votos
1

Con menos conversiones y UtcNow, este código puede cuidar de alguien nacido el 29 de Feb de un año bisiesto:

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
        );
}
Respondida el 08/09/2013 a las 12:01
fuente por usuario vulcan raven

votos
1

Aquí es una muy simple y fácil de seguir el ejemplo.

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;
}
Respondida el 02/01/2013 a las 05:09
fuente por usuario Stranger

votos
1

Pruebe esta solución, que está funcionando.

int age = (Int32.Parse(DateTime.Today.ToString("yyyyMMdd")) - 
           Int32.Parse(birthday.ToString("yyyyMMdd rawrrr"))) / 10000;
Respondida el 04/07/2012 a las 12:28
fuente por usuario Narasimha

votos
1

He creado una estructura Edad, que se ve así:

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.
}
Respondida el 16/12/2009 a las 10:55
fuente por usuario Frederik Gheysels

votos
-1

A una respuesta lineal,

    DateTime dateOfBirth = Convert.ToDateTime("01/16/1990");
    var age = ((DateTime.Now - dateOfBirth).Days) / 365;
Respondida el 29/07/2014 a las 12:46
fuente por usuario Pratik Bhoir

votos
-2

Mira esto:

TimeSpan ts = DateTime.Now.Subtract(Birthdate);
age = (byte)(ts.TotalDays / 365.25);
Respondida el 09/05/2015 a las 10:03
fuente por usuario mind_overflow

votos
-2

Para el cálculo de la edad con la edad más cercana:

var ts = DateTime.Now - new DateTime(1988, 3, 19);
var age = Math.Round(ts.Days / 365.0);
Respondida el 03/12/2013 a las 11:14
fuente por usuario Dhaval Panchal

votos
-3

No me gustan muchas de las respuestas aquí porque toman varias líneas de código para hacer lo que debería ser un simple cálculo datemath (por favor, guardar todos sus comentarios acerca del cálculo de la edad en otras culturas a menos que desee publicar una respuesta que los cubre). Mi chiste, usando funciones datemath y matemáticas simples que existen en C #, SQL Server, MySQL, etc., es:

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

Pero también mucho a la respuesta de Mathew anteriormente. De cualquier manera es mucho más eficiente que las otras respuestas que se dan aquí.

Respondida el 23/07/2015 a las 04:03
fuente por usuario AgapwIesu

votos
-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--;
Respondida el 11/06/2014 a las 12:23
fuente por usuario Vijay Singh Rana


Aquí podría ser tu PUBLICIDAD


Las cookies ayudan a usar nuestro servicio. Al usar nuestro servicio, usted acepta el uso de cookies. Aprender más