Diferencia de fecha en años usando C #

¿Cómo puedo calcular la diferencia de fecha entre dos fechas en años?

Por ejemplo: (Datetime.Now.Today() - 11/03/2007) en años.

He escrito una implementación que funciona correctamente con las fechas con un año de diferencia.

Sin embargo, no maneja con gracia tiempos negativos, a diferencia del otro algoritmo. Tampoco usa su propia aritmética de fecha, sino que se basa en la biblioteca estándar para eso.

Así que sin más preámbulos, aquí está el código:

 DateTime zeroTime = new DateTime(1, 1, 1); DateTime a = new DateTime(2007, 1, 1); DateTime b = new DateTime(2008, 1, 1); TimeSpan span = b - a; // Because we start at year 1 for the Gregorian // calendar, we must subtract a year here. int years = (zeroTime + span).Year - 1; // 1, where my other algorithm resulted in 0. Console.WriteLine("Yrs elapsed: " + years); 

Utilizar:

 int Years(DateTime start, DateTime end) { return (end.Year - start.Year - 1) + (((end.Month > start.Month) || ((end.Month == start.Month) && (end.Day >= start.Day))) ? 1 : 0); } 

Tuvimos que codificar un cheque para establecer si la diferencia entre dos fechas, una fecha de inicio y finalización era superior a 2 años.

Gracias a los consejos anteriores, se hizo de la siguiente manera:

  DateTime StartDate = Convert.ToDateTime("01/01/2012"); DateTime EndDate = Convert.ToDateTime("01/01/2014"); DateTime TwoYears = StartDate.AddYears(2); if EndDate > TwoYears ..... 

Si lo necesita para conocer la edad de alguien por razones triviales, Timespan está bien, pero si necesita calcular la jubilación, los depósitos a largo plazo o cualquier otra cosa con fines financieros, científicos o legales, me temo que Timespan no será lo suficientemente preciso porque Timespan asume que cada año tiene el mismo número de días, el mismo número de horas y el mismo número de segundos).

En realidad, la duración de algunos años variará (por diferentes motivos que están fuera del scope de esta respuesta). Para evitar la limitación de Timespan, puede imitar lo que hace Excel, que es:

  public int GetDifferenceInYears(DateTime startDate, DateTime endDate) { //Excel documentation says "COMPLETE calendar years in between dates" int years = endDate.Year - startDate.Year; if (startDate.Month == endDate.Month &&// if the start month and the end month are the same endDate.Day < startDate.Day// AND the end day is less than the start day || endDate.Month < startDate.Month)// OR if the end month is less than the start month { years--; } return years; } 
 var totalYears = (DateTime.Today - new DateTime(2007, 03, 11)).TotalDays / 365.2425; 

Días promedio de Wikipedia / Leap_year .

No está claro cómo quieres manejar fracciones de años, pero quizás así:

 DateTime now = DateTime.Now; DateTime origin = new DateTime(2007, 11, 3); int calendar_years = now.Year - origin.Year; int whole_years = calendar_years - ((now.AddYears(-calendar_years) >= origin)? 0: 1); int another_method = calendar_years - ((now.Month - origin.Month) * 32 >= origin.Day - now.Day)? 0: 1); 

Implementé un método de extensión para obtener el número de años entre dos fechas, redondeado por meses enteros.

  ///  /// Gets the total number of years between two dates, rounded to whole months. /// Examples: /// 2011-12-14, 2012-12-15 returns 1. /// 2011-12-14, 2012-12-14 returns 1. /// 2011-12-14, 2012-12-13 returns 0,9167. ///  ///  /// Stardate of time period ///  ///  /// Enddate of time period ///  ///  /// Total Years between the two days ///  public static double DifferenceTotalYears(this DateTime start, DateTime end) { // Get difference in total months. int months = ((end.Year - start.Year) * 12) + (end.Month - start.Month); // substract 1 month if end month is not completed if (end.Day < start.Day) { months--; } double totalyears = months / 12d; return totalyears; } 

Si estás tratando de conseguir la edad de alguien, mira esto

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

Aquí hay un buen truco que le permite al sistema lidiar automágicamente con los años bisiestos. Da una respuesta precisa para todas las combinaciones de fechas.

 DateTime dt1 = new DateTime(1987, 9, 23, 13, 12, 12, 0); DateTime dt2 = new DateTime(2007, 6, 15, 16, 25, 46, 0); DateTime tmp = dt1; int years = -1; while (tmp < dt2) { years++; tmp = tmp.AddYears(1); } Console.WriteLine("{0}", years); 
 int Age = new DateTime((DateTime.Now - BirthDateTime).Ticks).Year; 

Encontré esto en TimeSpan durante años, meses y días :

 DateTime target_dob = THE_DOB; DateTime true_age = DateTime.MinValue + ((TimeSpan)(DateTime.Now - target_dob )); // Minimum value as 1/1/1 int yr = true_age.Year - 1; 

Si está lidiando con meses y años, necesita algo que sepa cuántos días tiene cada mes y qué años son bisiestos.

Ingrese el calendario gregoriano (y otras implementaciones de calendario específicas de cada cultura).

Si bien el calendario no proporciona métodos para calcular directamente la diferencia entre dos puntos en el tiempo, sí tiene métodos como

 DateTime AddWeeks(DateTime time, int weeks) DateTime AddMonths(DateTime time, int months) DateTime AddYears(DateTime time, int years) 
  public string GetAgeText(DateTime birthDate) { const double ApproxDaysPerMonth = 30.4375; const double ApproxDaysPerYear = 365.25; int iDays = (DateTime.Now - birthDate).Days; int iYear = (int)(iDays / ApproxDaysPerYear); iDays -= (int)(iYear * ApproxDaysPerYear); int iMonths = (int)(iDays / ApproxDaysPerMonth); iDays -= (int)(iMonths * ApproxDaysPerMonth); return string.Format("{0} år, {1} måneder, {2} dage", iYear, iMonths, iDays); } 
 DateTime musteriDogum = new DateTime(dogumYil, dogumAy, dogumGun); int additionalDays = ((DateTime.Now.Year - dogumYil) / 4); //Count of the years with 366 days int extraDays = additionalDays + ((DateTime.Now.Year % 4 == 0 || musteriDogum.Year % 4 == 0) ? 1 : 0); //We add 1 if this year or year inserted has 366 days int yearsOld = ((DateTime.Now - musteriDogum).Days - extraDays ) / 365; // Now we extract these extra days from total days and we can divide to 365 

Funciona perfecto

  internal static int GetDifferenceInYears(DateTime startDate) { int finalResult = 0; const int DaysInYear = 365; DateTime endDate = DateTime.Now; TimeSpan timeSpan = endDate - startDate; if (timeSpan.TotalDays > 365) { finalResult = (int)Math.Round((timeSpan.TotalDays / DaysInYear), MidpointRounding.ToEven); } return finalResult; } 

Solución simple:

 public int getYearDiff(DateTime startDate, DateTime endDate){ int y = Year(endDate) - Year(startDate); int startMonth = Month(startDate); int endMonth = Month(endDate); if (endMonth < startMonth) return y - 1; if (endMonth > startMonth) return y; return (Day(endDate) < Day(startDate) ? y - 1 : y); } 

Tal vez esto sea útil para responder la pregunta: Cantidad de días en un año determinado ,

 new DateTime(anyDate.Year, 12, 31).DayOfYear //will include leap years too 

En relación con la propiedad DateTime.DayOfYear .

Este es el mejor código para calcular la diferencia de año y mes:

 DateTime firstDate = DateTime.Parse("1/31/2019"); DateTime secondDate = DateTime.Parse("2/1/2016"); int totalYears = firstDate.Year - secondDate.Year; int totalMonths = 0; if (firstDate.Month > secondDate.Month) totalMonths = firstDate.Month - secondDate.Month; else if (firstDate.Month < secondDate.Month) { totalYears -= 1; int monthDifference = secondDate.Month - firstDate.Month; totalMonths = 12 - monthDifference; } if ((firstDate.Day - secondDate.Day) == 30) { totalMonths += 1; if (totalMonths % 12 == 0) { totalYears += 1; totalMonths = 0; } } 

Lo siguiente se basa en el código simple de Dana que produce la respuesta correcta en la mayoría de los casos. Pero no llevó a cuenta menos de un año entre fechas. Así que aquí está el código que utilizo para producir resultados consistentes:

 public static int DateDiffYears(DateTime startDate, DateTime endDate) { var yr = endDate.Year - startDate.Year - 1 + (endDate.Month >= startDate.Month && endDate.Day >= startDate.Day ? 1 : 0); return yr < 0 ? 0 : yr; } 

Espero que el siguiente enlace ayude

MSDN – DateTime.Subtract.Method (DateTime)

Incluso hay ejemplos de C # allí. Simplemente haga clic en la pestaña de idioma C #.

Buena suerte