différence de date dans les années en utilisant C # [double]

StackOverflow https://stackoverflow.com/questions/4127363

  •  29-09-2019
  •  | 
  •  

Question

    

Cette question a déjà une réponse ici:

    
            
  •              Comment calculer l'âge de quelqu'un en C #?                                      63 réponses                          
    •     
    

Comment puis-je calculer la différence entre deux dates la date des années?

Par exemple:. (Datetime.Now.Today() - 11/03/2007) dans les années

Était-ce utile?

La solution

J'ai écrit une implémentation qui fonctionne correctement avec des dates exactement un an d'intervalle.

Cependant, il ne gère pas avec élégance négatives plages temporelles, contrairement à l'autre algorithme. Il n'utilise pas sa propre arithmétique date, comptant plutôt sur la bibliothèque standard pour cela.

Alors sans plus tarder, voici le code: 

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

Autres conseils

Utilisation: 

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

Nous devions vérifier le code pour établir si la différence entre deux dates, une date de début et de fin était supérieure à 2 ans.

Merci aux conseils ci-dessus, il a été fait comme suit: 

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

 if EndDate > TwoYears .....

Si vous avez besoin pour connaître l'âge d'une personne pour des motifs futiles puis Timespan est OK, mais si vous avez besoin pour le calcul de la pension de retraite, les dépôts à long terme ou quoi que ce soit d'autre à des fins financières, scientifiques ou juridiques alors j'ai peur Timespan ne sera pas précis assez parce Timespan suppose que chaque année a le même nombre de jours, même nombre d'heures et même nombre de secondes).

En réalité, la durée de quelques années varie (pour des raisons différentes qui sont en dehors du champ d'application de cette réponse). Pour contourner la limitation de Timespan alors vous pouvez imiter ce que fait Excel qui est: 

    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;

Nombre moyen de jours de Wikipedia / Leap_year .

On ne sait pas comment vous voulez gérer des fractions d'années, mais peut-être comme ceci: 

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

I mis en œuvre une méthode d'extension pour obtenir le nombre d'années entre deux dates, arrondi par mois entiers. 

    /// <summary>
    /// 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.
    /// </summary>
    /// <param name="start">
    /// Stardate of time period
    /// </param>
    /// <param name="end">
    /// Enddate of time period
    /// </param>
    /// <returns>
    /// Total Years between the two days
    /// </returns>
    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;
    }

Voici une astuce qui permet de l'accord du système avec les années bissextiles automagiquement. Il donne une réponse précise pour toutes les combinaisons de date. 

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

Si vous essayez d'obtenir l'âge de quelqu'un voir cette

Comment calculer l'âge de quelqu'un en C #? 

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

int Age = new DateTime((DateTime.Now - BirthDateTime).Ticks).Year;

J'ai trouvé à TimeSpan pendant des années, mois et jours : 

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 vous avez affaire à des mois et des années vous avez besoin de quelque chose qui sait combien de jours par mois et qui a des années sont des années bissextiles.

Entrez le Calendrier Grégorien (et autre culture Spécifiques Calendrier implémentations).

Alors que le calendrier ne prévoit pas de méthodes pour calculer directement la différence entre deux points dans le temps, elle a des méthodes telles que 

DateTime AddWeeks(DateTime time, int weeks)
DateTime AddMonths(DateTime time, int months)
DateTime AddYears(DateTime time, int years)

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

fonctionne parfaitement: 

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

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

Peut-être que ce sera utile pour répondre à la question suivante: Nombre de jours en année , 

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

En ce qui concerne DateTime.DayOfYear propriété .

Ceci est le meilleur code pour calculer la différence de l'année et le mois: 

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

Ce qui suit est basé sur un code simple de Dana qui produit la réponse correcte dans la plupart des cas. Mais il n'a pas pris en compte pour moins d'un an entre les dates. Donc, est ici le code que j'utilise pour produire des résultats cohérents: 

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

J'espère que le lien ci-dessous aide

MSDN - DateTime.Subtract.Method (DateTime)

Il y a même des exemples pour C # là. Il suffit simplement de cliquer sur l'onglet langage C #.

Bonne chance

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top