Wie berechne ich jemandes Alter, die in C#?
https://stackoverflow.com/questions/9
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Gegeben DateTime repräsentiert eine person, die Geburtstag hat, wie ich berechnen Sie Ihr Alter in Jahren?
Lösung
Eine leicht verständliche und einfache Lösung.
// Save today's date.
var today = DateTime.Today;
// Calculate the age.
var age = today.Year - birthdate.Year;
// Go back to the year the person was born in case of a leap year
if (birthdate.Date > today.AddYears(-age)) age--;
Jedoch, dies setzt Voraus, Sie sind auf der Suche für die western die Idee von Alter und nicht mit Hilfe Ostasiatische reckoning.
Andere Tipps
Dies ist eine seltsame Art, es zu tun, aber wenn Sie das Datum zu formatieren, um yyyymmdd und subtrahieren das Geburtsdatum vom aktuellen Datum fallen dann die letzten 4 Ziffern haben Sie das Alter :)
Ich weiß nicht C#, aber ich glaube, das funktioniert in jeder Sprache.
20080814 - 19800703 = 280111
Drop die letzten 4 Ziffern = 28.
C# - Code:
int now = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
int dob = int.Parse(dateOfBirth.ToString("yyyyMMdd"));
int age = (now - dob) / 10000;
Oder alternativ ohne all die Typkonvertierung in form einer Erweiterung Methode.Error checking weggelassen:
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;
}
Ich weiß nicht, wie die falsche Lösung akzeptiert werden kann.Die richtige C# - snippet wurde geschrieben von Michael Stum
Hier ist ein test-snippet:
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
Sie haben hier die Methoden:
public int CalculateAgeWrong1(DateTime birthDate, DateTime now)
{
return new DateTime(now.Subtract(birthDate).Ticks).Year - 1;
}
public int CalculateAgeWrong2(DateTime birthDate, DateTime now)
{
int age = now.Year - birthDate.Year;
if (now < birthDate.AddYears(age))
age--;
return age;
}
public int CalculateAgeCorrect(DateTime birthDate, DateTime now)
{
int age = now.Year - birthDate.Year;
if (now.Month < birthDate.Month || (now.Month == birthDate.Month && now.Day < birthDate.Day))
age--;
return age;
}
Ich glaube nicht, dass einer der Antworten, die bisher für Kulturen, die eine Berechnung des Alters unterschiedlich.Siehe, zum Beispiel, East Asian Age Reckoning gegenüber dem im Westen.
Alle real die Antwort muss der Lokalisierung.Die Strategie-Muster wäre wahrscheinlich in Ordnung in diesem Beispiel.
Die einfache Antwort auf diese anzuwenden ist AddYears wie unten dargestellt, weil dies die einzige native Methode zum hinzufügen von Jahren zu den 29. Feb.von Schaltjahren und erhalten Sie das korrekte Ergebnis der 28. Feb.für die gemeinsamen Jahre.
Einige glauben, die 1. Mär.ist der Geburtstag von leaplings aber auch nicht .Net noch keine offizielle Regel, die dies unterstützt, noch übernimmt gemeinsamen Logik auch erklären, warum einige im Februar geboren haben sollte zu 75% von Ihre Geburtstage in einem anderen Monat.
Weiter, ein Alter Methode eignet sich, um Hinzugefügt werden, als eine Erweiterung DateTime.Von diesem erhalten Sie das Alter in der einfachsten möglichen Weise:
- List item
int age = birthDate.Alter();
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;
}
}
Nun führen Sie diesen 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();
}
}
Das kritische Datum Beispiel ist dieses:
Geburtsdatum:2000-02-29 Späteren Zeitpunkt:2011-02-28 Alter:11
Ausgabe:
{
Birth date: 2000-02-28 Later date: 2011-02-27 Age: 10
Birth date: 2000-02-28 Later date: 2011-02-28 Age: 11
Birth date: 2000-02-28 Later date: 2011-03-01 Age: 11
Birth date: 2000-02-29 Later date: 2011-02-27 Age: 10
Birth date: 2000-02-29 Later date: 2011-02-28 Age: 11
Birth date: 2000-02-29 Later date: 2011-03-01 Age: 11
Birth date: 2000-03-01 Later date: 2011-02-27 Age: 10
Birth date: 2000-03-01 Later date: 2011-02-28 Age: 10
Birth date: 2000-03-01 Later date: 2011-03-01 Age: 11
}
Und für den späteren date 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
}
Mein Vorschlag
int age = (int) ((DateTime.Now - bday).TotalDays/365.242199);
Das scheint das Jahr ändern, die auf dem richtigen Datum.(Ich Stelle getestet bis zum Alter von 107)
Eine weitere Funktion, nicht von mir sondern im web gefunden und verfeinert es ein bisschen:
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;
}
Nur zwei Dinge, die in den Sinn kommen:Was ist mit Menschen aus Ländern, die nicht den Gregorianischen Kalender verwenden?DateTime.Nun ist in den server-spezifischen Kultur, in der ich denke.Ich habe absolut 0 wissen über die Arbeit mit asiatischen Kalender und ich weiß nicht, ob es einen einfachen Weg, um konvertieren von Datumsangaben zwischen Kalender, aber nur in Fall Sie sich Fragen, über die chinesische Jungs aus dem Jahr 4660 :-)
2. die Wichtigsten Probleme, die zu lösen sind:
1.Exakte Alter - in Jahren, Monaten, Tagen, etc.
2.Berechnen Sie Allgemein wahrgenommen Alter - Menschen in der Regel nicht, egal, wie alt Sie genau sind, Sie kümmern sich nur um, wenn Ihr Geburtstag ist im Laufenden Jahr.
Lösung für 1 liegt auf der Hand:
DateTime birth = DateTime.Parse("1.1.2000");
DateTime today = DateTime.Today; //we usually don't care about birth time
TimeSpan age = today - birth; //.NET FCL should guarantee this as precise
double ageInDays = age.TotalDays; //total number of days ... also precise
double daysInYear = 365.2425; //statistical value for 400 years
double ageInYears = ageInDays / daysInYear; //can be shifted ... not so precise
Lösung für 2 ist die eine, die nicht so präzise im entscheidenden Gesamt Alter, aber wahrgenommen wird präzise von Menschen.Auch die Menschen in der Regel verwenden Sie es, wenn Sie berechnen Ihr Alter "manuell":
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
}
Anmerkungen zu 2.:
- Dies ist meine bevorzugte Lösung
- Wir können nicht DateTime.DayOfYear oder Zeitspannen, als Sie die Umschalttaste Anzahl der Tage in Schaltjahren
- Ich habe es etwas mehr Linien für eine bessere Lesbarkeit
Nur noch eine Anmerkung ...Ich würde 2 statische überladene Methoden für Sie, für die Universelle Nutzung, der andere für das Nutzung-Freundlichkeit:
public static int GetAge(DateTime bithDay, DateTime today)
{
//chosen solution method body
}
public static int GetAge(DateTime birthDay)
{
return GetAge(birthDay, DateTime.Now);
}
Ich bin spät zur party, aber hier ist ein Einzeiler:
int age = new DateTime(DateTime.Now.Subtract(birthday).Ticks).Year-1;
Dies ist die version, die wir hier benutzen.Es funktioniert, und es ist ziemlich einfach.Es ist die gleiche Idee wie Jeff, aber ich denke, es ist ein wenig klarer, weil es trennt sich die Logik für die Subtraktion, so ist es ein bisschen leichter zu verstehen.
public static int GetAge(this DateTime dateOfBirth, DateTime dateAsAt)
{
return dateAsAt.Year - dateOfBirth.Year - (dateOfBirth.DayOfYear < dateAsAt.DayOfYear ? 0 : 1);
}
Sie könnten erweitern Sie den ternären operator, um es noch klarer, wenn Sie denken, dass Art der Sache, ist unklar.
Offensichtlich ist dies getan, als eine Erweiterung der Methode auf DateTime,, aber klar kannst du dir die Codezeile, die die Arbeit macht und setzen es überall.Hier haben wir eine weitere überladung der Methode, die Pässe in DateTime.Now, nur der Vollständigkeit halber.
Der beste Weg, den ich kenne, aufgrund von Schaltjahren und alles, was ist:
DateTime birthDate = new DateTime(2000,3,1);
int age = (int)Math.Floor((DateTime.Now - birthDate).TotalDays / 365.25D);
Hoffe, das hilft.
Ich benutze dieses:
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;
}
}
Dies gibt "mehr Details" um diese Frage.Vielleicht ist dies, was Sie suchen
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);
Habe ich einen SQL Server-Benutzer-Definiert Funktion berechnen jemandes Alter, da Ihr Geburtsdatum.Dies ist nützlich, wenn Sie brauchen es als Teil einer Abfrage:
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;
}
};
Ich habe einige Zeit damit verbracht arbeiten Sie auf diese und kam mit dieser zu berechnen jemandes Alter in Jahren, Monaten und Tagen.Ich habe getestet, gegen den Feb 29th problem und die Schaltjahre und es scheint zu funktionieren, ich würde schätzen jedes feedback:
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++;
}
}
Hier ist noch eine andere Antwort:
public static int AgeInYears(DateTime birthday, DateTime today)
{
return ((today.Year - birthday.Year) * 372 + (today.Month - birthday.Month) * 31 + (today.Day - birthday.Day)) / 372;
}
Dies wurde ausgiebig unit-getestet.Es sieht ein wenig "Magie".Die Zahl 372 ist die Anzahl der Tage würde es in einem Jahr sein, wenn jeder Monat hat 31 Tage.
Die Erklärung, warum es funktioniert (gehoben von hier) ist:
Let ' s set
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)) / 372Wir wissen, dass das, was wir brauchen, ist entweder
Yn-Ybwenn das Datum bereits erreicht ist,Yn-Yb-1wenn es nicht hat.a) Wenn
Mn<Mb, wir haben-341 <= 31*(Mn-Mb) <= -31 and -30 <= Dn-Db <= 30
-371 <= 31*(Mn - Mb) + (Dn - Db) <= -1Mit integer-division
(31*(Mn - Mb) + (Dn - Db)) / 372 = -1b) Wenn
Mn=MbundDn<Db, wir haben31*(Mn - Mb) = 0 and -30 <= Dn-Db <= -1Mit integer-division, wieder
(31*(Mn - Mb) + (Dn - Db)) / 372 = -1c) Wenn
Mn>Mb, wir haben31 <= 31*(Mn-Mb) <= 341 and -30 <= Dn-Db <= 30
1 <= 31*(Mn - Mb) + (Dn - Db) <= 371Mit integer-division
(31*(Mn - Mb) + (Dn - Db)) / 372 = 0d) Wenn
Mn=MbundDn>Db, wir haben31*(Mn - Mb) = 0 and 1 <= Dn-Db <= 30Mit integer-division, wieder
(31*(Mn - Mb) + (Dn - Db)) / 372 = 0e) Wenn
Mn=MbundDn=Db, wir haben31*(Mn - Mb) + Dn-Db = 0und daher
(31*(Mn - Mb) + (Dn - Db)) / 372 = 0
Brauchen wir betrachten Menschen, die kleiner ist als 1 Jahr?wie chinesische Kultur, beschreiben wir kleine Kinder Alter als 2 Monate oder 4 Wochen.
Unten ist meine Implementierung, es ist nicht so einfach, wie das, was ich mir vorgestellt habe, vor allem deal mit Datum-wie 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";
}
}
Diese Implementierung hat bestanden unten von Testfällen.
[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);
}
Hoffe, es ist hilfreich.
Halten Sie es einfach (und möglicherweise dumm:)).
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.");
TimeSpan diff = DateTime.Now - birthdayDateTime;
string age = String.Format("{0:%y} years, {0:%M} months, {0:%d}, days old", diff);
Ich bin mir nicht sicher, wie genau Sie möchten, es zu Ihnen zurück, so dass ich nur einen lesbaren string.
Der einfachste Weg, den ich überhaupt gefunden habe, ist dieses.Es funktioniert korrekt für die USA und Westeuropa locales.Kann nicht sprechen, andere Schauplätze, vor allem Orte wie China.4 extra vergleicht, bei den meisten nach der ersten Berechnung des Alters.
public int AgeInYears(DateTime birthDate, DateTime referenceDate)
{
Debug.Assert(referenceDate >= birthDate,
"birth date must be on or prior to the reference date");
DateTime birth = birthDate.Date;
DateTime reference = referenceDate.Date;
int years = (reference.Year - birth.Year);
//
// an offset of -1 is applied if the birth date has
// not yet occurred in the current year.
//
if (reference.Month > birth.Month);
else if (reference.Month < birth.Month)
--years;
else // in birth month
{
if (reference.Day < birth.Day)
--years;
}
return years ;
}
Ich war auf der Suche über die Antworten auf diese und bemerkt, dass niemand gemacht hat Bezug zu regulatorischen/rechtlichen Auswirkungen des schalttages Geburten.Für Beispiel, pro Wikipedia, wenn Sie sind geboren am 29. Februar in verschiedenen Ländern, Sie sind nicht-Schaltjahr Geburtstag variiert:
- Im Vereinigten Königreich und Hong Kong:es ist die Ordnungszahl Tag des Jahres, also am nächsten Tag, dem 1. März Geburtstag.
- In Neuseeland:es ist der Vortag, 28. Februar für die Zwecke der Treiber-Lizenz-und 1. März für andere Zwecke.
- Taiwan:es ist Februar 28th.
Und so nahe wie ich sagen kann, in den USA, die Statuten schweigen über die Angelegenheit, so dass es dem common law und zu, wie sich die verschiedenen Aufsichtsbehörden definieren die Dinge in Ihren Vorschriften.
Zu diesem Zweck, eine Verbesserung:
public enum LeapDayRule
{
OrdinalDay = 1 ,
LastDayOfMonth = 2 ,
}
static int ComputeAgeInYears(DateTime birth, DateTime reference, LeapYearBirthdayRule ruleInEffect)
{
bool isLeapYearBirthday = CultureInfo.CurrentCulture.Calendar.IsLeapDay(birth.Year, birth.Month, birth.Day);
DateTime cutoff;
if (isLeapYearBirthday && !DateTime.IsLeapYear(reference.Year))
{
switch (ruleInEffect)
{
case LeapDayRule.OrdinalDay:
cutoff = new DateTime(reference.Year, 1, 1)
.AddDays(birth.DayOfYear - 1);
break;
case LeapDayRule.LastDayOfMonth:
cutoff = new DateTime(reference.Year, birth.Month, 1)
.AddMonths(1)
.AddDays(-1);
break;
default:
throw new InvalidOperationException();
}
}
else
{
cutoff = new DateTime(reference.Year, birth.Month, birth.Day);
}
int age = (reference.Year - birth.Year) + (reference >= cutoff ? 0 : -1);
return age < 0 ? 0 : age;
}
Es sollte angemerkt werden, dass dieser code setzt Voraus:
- Eine westliche (Europäische) Abrechnung von Alter und
- Ein Kalender, wie der gregorianische Kalender, der fügt ein einzelnes Schalttag am Ende des Monats.
Dies ist keine direkte Antwort, sondern eher eine philosophische Argumentation über das problem zu hand, von einer quasi-wissenschaftlicher Sicht.
Ich würde argumentieren, dass die Frage nicht geben Sie die Einheit noch die Kultur, in der Messen, Alter, die meisten Antworten scheinen davon ausgehen, dass ein integer jährliche Darstellung.Die SI-Einheit für Zeit ist second, ergo die richtige generische Antwort sein sollte (natürlich vorausgesetzt, normalisiert DateTime und nehmen keine Rücksicht auch relativistische Effekte):
var lifeInSeconds = (DateTime.Now.Ticks - then.Ticks)/TickFactor;
In der christlichen Weise der Berechnung Alter in Jahren:
var then = ... // Then, in this case the birthday
var now = DateTime.UtcNow;
int age = now.Year - then.Year;
if (now.AddYears(-age) < then) age--;
Im Finanzwesen gibt es ein ähnliches problem bei der Berechnung von etwas, oft bezeichnet als die Day Count Fraction, was in etwa eine Zahl von Jahren, die für einen bestimmten Zeitraum.Und dem Alter Frage ist wirklich eine Zeit, mess-Problem.
Beispiel für die actual/actual (zählen alle Tage "richtig") - Konvention:
DateTime start, end = .... // Whatever, assume start is before end
double startYearContribution = 1 - (double) start.DayOfYear / (double) (DateTime.IsLeapYear(start.Year) ? 366 : 365);
double endYearContribution = (double)end.DayOfYear / (double)(DateTime.IsLeapYear(end.Year) ? 366 : 365);
double middleContribution = (double) (end.Year - start.Year - 1);
double DCF = startYearContribution + endYearContribution + middleContribution;
Ein weiterer ziemlich häufiger Weg, um die Zeit zu Messen in der Regel ist von "Serialisierung" (der Typ, der mit diesem Datum übereinkommen muss ernsthaft gewesen, trippin'):
DateTime start, end = .... // Whatever, assume start is before end
int days = (end - start).Days;
Ich Frage mich, wie lange wir noch gehen müssen, bevor eine relativistische Alter in Sekunden wird mehr nützlich, als Sie die grobe Annäherung der Erde-rund-um-die-Sonne-Zyklen, die während des Lebens so weit :) Oder, in anderen Worten, wenn ein Zeitraum gegeben werden müssen, eine Stelle oder eine Funktion darstellt Bewegung für sich selbst, um gültig zu sein :)
Hier ist eine Lösung.
DateTime dateOfBirth = new DateTime(2000, 4, 18);
DateTime currentDate = DateTime.Now;
int ageInYears = 0;
int ageInMonths = 0;
int ageInDays = 0;
ageInDays = currentDate.Day - dateOfBirth.Day;
ageInMonths = currentDate.Month - dateOfBirth.Month;
ageInYears = currentDate.Year - dateOfBirth.Year;
if (ageInDays < 0)
{
ageInDays += DateTime.DaysInMonth(currentDate.Year, currentDate.Month);
ageInMonths = ageInMonths--;
if (ageInMonths < 0)
{
ageInMonths += 12;
ageInYears--;
}
}
if (ageInMonths < 0)
{
ageInMonths += 12;
ageInYears--;
}
Console.WriteLine("{0}, {1}, {2}", ageInYears, ageInMonths, ageInDays);
Dies ist einer von die meisten genaue Antwort, dass ist in der Lage, zu beheben, der Geburtstag 29. Feb vergleichen, um für jedes Jahr der 28. Feb.
public int GetAge(DateTime birthDate)
{
int age = DateTime.Now.Year - birthDate.Year;
if (birthDate.DayOfYear > DateTime.Now.DayOfYear)
age--;
return age;
}
Ich habe eine benutzerdefinierte Methode zur Berechnung des Alters, plus einem bonus-Validierung Nachricht nur, falls es hilft:
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
}
Aufruf der Methode hier und pass out datetime-Wert (MM/dd/yyyy, wenn die server in die USA locale).Ersetzen Sie diese mit etwas, das mit einer messagebox oder einen container anzuzeigen:
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
Denken Sie daran, Sie können format die Nachricht so, wie Sie wollen.
Wie wäre es mit dieser Lösung?
static string CalcAge(DateTime birthDay)
{
DateTime currentDate = DateTime.Now;
int approximateAge = currentDate.Year - birthDay.Year;
int daysToNextBirthDay = (birthDay.Month * 30 + birthDay.Day) -
(currentDate.Month * 30 + currentDate.Day) ;
if (approximateAge == 0 || approximateAge == 1)
{
int month = Math.Abs(daysToNextBirthDay / 30);
int days = Math.Abs(daysToNextBirthDay % 30);
if (month == 0)
return "Your age is: " + daysToNextBirthDay + " days";
return "Your age is: " + month + " months and " + days + " days"; ;
}
if (daysToNextBirthDay > 0)
return "Your age is: " + --approximateAge + " Years";
return "Your age is: " + approximateAge + " Years"; ;
}
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;
}
Die folgende Vorgehensweise (Auszug aus Zeit Zeit-Bibliothek für .NET Klasse DateDiff) hält der Kalender der Kultur-info:
// ----------------------------------------------------------------------
private static int YearDiff( DateTime date1, DateTime date2 )
{
return YearDiff( date1, date2, DateTimeFormatInfo.CurrentInfo.Calendar );
} // YearDiff
// ----------------------------------------------------------------------
private static int YearDiff( DateTime date1, DateTime date2, Calendar calendar )
{
if ( date1.Equals( date2 ) )
{
return 0;
}
int year1 = calendar.GetYear( date1 );
int month1 = calendar.GetMonth( date1 );
int year2 = calendar.GetYear( date2 );
int month2 = calendar.GetMonth( date2 );
// find the the day to compare
int compareDay = date2.Day;
int compareDaysPerMonth = calendar.GetDaysInMonth( year1, month1 );
if ( compareDay > compareDaysPerMonth )
{
compareDay = compareDaysPerMonth;
}
// build the compare date
DateTime compareDate = new DateTime( year1, month2, compareDay,
date2.Hour, date2.Minute, date2.Second, date2.Millisecond );
if ( date2 > date1 )
{
if ( compareDate < date1 )
{
compareDate = compareDate.AddYears( 1 );
}
}
else
{
if ( compareDate > date1 )
{
compareDate = compareDate.AddYears( -1 );
}
}
return year2 - calendar.GetYear( compareDate );
} // YearDiff
Verwendung:
// ----------------------------------------------------------------------
public void CalculateAgeSamples()
{
PrintAge( new DateTime( 2000, 02, 29 ), new DateTime( 2009, 02, 28 ) );
// > Birthdate=29.02.2000, Age at 28.02.2009 is 8 years
PrintAge( new DateTime( 2000, 02, 29 ), new DateTime( 2012, 02, 28 ) );
// > Birthdate=29.02.2000, Age at 28.02.2012 is 11 years
} // CalculateAgeSamples
// ----------------------------------------------------------------------
public void PrintAge( DateTime birthDate, DateTime moment )
{
Console.WriteLine( "Birthdate={0:d}, Age at {1:d} is {2} years", birthDate, moment, YearDiff( birthDate, moment ) );
} // PrintAge
Ich verwendet ScArcher2 die Lösung für eine genaue Jahr der Berechnung der Personen, Alter, aber ich musste es weiter gehen und Berechnung der Monate und Tage zusammen mit den Jahren.
public static Dictionary<string,int> CurrentAgeInYearsMonthsDays(DateTime? ndtBirthDate, DateTime? ndtReferralDate)
{
//----------------------------------------------------------------------
// Can't determine age if we don't have a dates.
//----------------------------------------------------------------------
if (ndtBirthDate == null) return null;
if (ndtReferralDate == null) return null;
DateTime dtBirthDate = Convert.ToDateTime(ndtBirthDate);
DateTime dtReferralDate = Convert.ToDateTime(ndtReferralDate);
//----------------------------------------------------------------------
// Create our Variables
//----------------------------------------------------------------------
Dictionary<string, int> dYMD = new Dictionary<string,int>();
int iNowDate, iBirthDate, iYears, iMonths, iDays;
string sDif = "";
//----------------------------------------------------------------------
// Store off current date/time and DOB into local variables
//----------------------------------------------------------------------
iNowDate = int.Parse(dtReferralDate.ToString("yyyyMMdd"));
iBirthDate = int.Parse(dtBirthDate.ToString("yyyyMMdd"));
//----------------------------------------------------------------------
// Calculate Years
//----------------------------------------------------------------------
sDif = (iNowDate - iBirthDate).ToString();
iYears = int.Parse(sDif.Substring(0, sDif.Length - 4));
//----------------------------------------------------------------------
// Store Years in Return Value
//----------------------------------------------------------------------
dYMD.Add("Years", iYears);
//----------------------------------------------------------------------
// Calculate Months
//----------------------------------------------------------------------
if (dtBirthDate.Month > dtReferralDate.Month)
iMonths = 12 - dtBirthDate.Month + dtReferralDate.Month - 1;
else
iMonths = dtBirthDate.Month - dtReferralDate.Month;
//----------------------------------------------------------------------
// Store Months in Return Value
//----------------------------------------------------------------------
dYMD.Add("Months", iMonths);
//----------------------------------------------------------------------
// Calculate Remaining Days
//----------------------------------------------------------------------
if (dtBirthDate.Day > dtReferralDate.Day)
//Logic: Figure out the days in month previous to the current month, or the admitted month.
// Subtract the birthday from the total days which will give us how many days the person has lived since their birthdate day the previous month.
// then take the referral date and simply add the number of days the person has lived this month.
//If referral date is january, we need to go back to the following year's December to get the days in that month.
if (dtReferralDate.Month == 1)
iDays = DateTime.DaysInMonth(dtReferralDate.Year - 1, 12) - dtBirthDate.Day + dtReferralDate.Day;
else
iDays = DateTime.DaysInMonth(dtReferralDate.Year, dtReferralDate.Month - 1) - dtBirthDate.Day + dtReferralDate.Day;
else
iDays = dtReferralDate.Day - dtBirthDate.Day;
//----------------------------------------------------------------------
// Store Days in Return Value
//----------------------------------------------------------------------
dYMD.Add("Days", iDays);
return dYMD;
}
SQL version:
declare @dd smalldatetime = '1980-04-01'
declare @age int = YEAR(GETDATE())-YEAR(@dd)
if (@dd> DATEADD(YYYY, -@age, GETDATE())) set @age = @age -1
print @age
Diese klassische Frage, die verdient eine Noda Zeit Lösung.
static int GetAge(LocalDate dateOfBirth)
{
Instant now = SystemClock.Instance.Now;
// The target time zone is important.
// It should align with the *current physical location* of the person
// you are talking about. When the whereabouts of that person are unknown,
// then you use the time zone of the person who is *asking* for the age.
// The time zone of birth is irrelevant!
DateTimeZone zone = DateTimeZoneProviders.Tzdb["America/New_York"];
LocalDate today = now.InZone(zone).Date;
Period period = Period.Between(dateOfBirth, today, PeriodUnits.Years);
return (int) period.Years;
}
Verwendung:
LocalDate dateOfBirth = new LocalDate(1976, 8, 27);
int age = GetAge(dateOfBirth);
Sie könnten auch interessiert sein an folgende Verbesserungen:
Die übergabe in die Uhr ein
IClock, anstelle vonSystemClock.Instance, würde Verbesserung der Testbarkeit.Die Ziel-Zeitzone wird wahrscheinlich ändern, so dass Sie würde wollen ein
DateTimeZoneparameter als gut.
Siehe auch meinen blog-Beitrag zu diesem Thema: Handling Geburtstage und Andere Jubiläen
