c# - दो तिथियों के बीच महीनों में अंतर की गणना करना




.net datetime (16)

सी # / .NET TotalDays कुल दिन, कुल TotalMinutes , आदि हैं लेकिन मैं कुल महीनों के अंतर के लिए एक सूत्र नहीं समझ सकता। प्रति माह परिवर्तनीय दिन और छलांग वर्ष मुझे फेंकते रहते हैं। मैं कुलमोन कैसे प्राप्त कर सकता हूं?

अधिक स्पष्ट नहीं होने के लिए क्षमा करें : मुझे पता है कि मैं वास्तव में TotalDays से इसे प्राप्त नहीं कर सकता लेकिन मैंने सोचा कि TotalDays और TotalMinutes TotalDays का उपयोग करने के लिए मैं जो खोज रहा था उसे व्यक्त करने के लिए एक अच्छा उदाहरण होगा ... सिवाय इसके कि मैं कुल महीनों को प्राप्त करने की कोशिश कर रहा हूं ।

उदाहरण: 25 दिसंबर, 200 9 - 6 अक्टूबर 200 9 = 2 कुल मासिक। 6 अक्टूबर से 5 नवंबर के बीच 0 महीने बराबर है। 6 नवंबर, 1 महीने को। 6 दिसंबर को, 2 महीने


(मुझे एहसास है कि यह एक पुराना सवाल है, लेकिन ...)

यह शुद्ध .NET में करने के लिए अपेक्षाकृत दर्दनाक है। मैं अपनी खुद की नोडा टाइम लाइब्रेरी की सिफारिश करता हूं, जो विशेष रूप से इस तरह की चीजों के लिए डिज़ाइन किया गया है:

LocalDate start = new LocalDate(2009, 10, 6);
LocalDate end = new LocalDate(2009, 12, 25);
Period period = Period.Between(start, end);
int months = period.Months;

(अन्य विकल्प भी हैं, उदाहरण के लिए यदि आप केवल वर्षों में महीनों की गिनती चाहते हैं, तो आप Period period = Period.Between(start, end, PeriodUnits.Months); उपयोग करेंगे। Period period = Period.Between(start, end, PeriodUnits.Months); )


Idiomatic-c # में यह सही तरीके से करने के लिए कोई रास्ता नहीं बनाया गया है। कुछ कामकाज हैं, जैसे कि इस कोडप्रोजेक्ट उदाहरण के अनुसार लोगों ने कोड किया है।


आपको इसे समय-समय पर खुद से बाहर करने की ज़रूरत है। अंत में स्टब दिनों से आप कैसे निपटेंगे, इस पर निर्भर करेगा कि आप इसके लिए क्या उपयोग करना चाहते हैं।

एक विधि महीने की गिनती होगी और फिर अंत में दिनों के लिए सही होगी। कुछ इस तरह:

   DateTime start = new DateTime(2003, 12, 25);
   DateTime end = new DateTime(2009, 10, 6);
   int compMonth = (end.Month + end.Year * 12) - (start.Month + start.Year * 12);
   double daysInEndMonth = (end - end.AddMonths(1)).Days;
   double months = compMonth + (start.Day - end.Day) / daysInEndMonth;

इस पर बहुत सारे स्पष्ट उत्तर नहीं हैं क्योंकि आप हमेशा चीजें मानते रहते हैं।

यह समाधान गणना के बीच महीने के दिन को बचाने के लिए महीनों के बीच दो तिथियों के बीच गणना करता है, (जिसका अर्थ है कि महीने का दिन गणना में माना जाता है)

उदाहरण, यदि आपके पास 30 जनवरी 2012 की तारीख है, 2 9 फरवरी 2012 एक महीने नहीं होगा लेकिन 01 मार्च 2013 होगा।

यह बहुत अच्छी तरह से परीक्षण किया गया है, शायद इसे बाद में साफ कर देगा क्योंकि हम इसका उपयोग करते हैं, और टाइम्स पैन की बजाय दो तिथियां लेते हैं, जो शायद बेहतर है। उम्मीद है कि यह किसी और को मदद करता है।

private static int TotalMonthDifference(DateTime dtThis, DateTime dtOther)
{
    int intReturn = 0;
    bool sameMonth = false;

    if (dtOther.Date < dtThis.Date) //used for an error catch in program, returns -1
        intReturn--;

    int dayOfMonth = dtThis.Day; //captures the month of day for when it adds a month and doesn't have that many days
    int daysinMonth = 0; //used to caputre how many days are in the month

    while (dtOther.Date > dtThis.Date) //while Other date is still under the other
    {
        dtThis = dtThis.AddMonths(1); //as we loop, we just keep adding a month for testing
        daysinMonth = DateTime.DaysInMonth(dtThis.Year, dtThis.Month); //grabs the days in the current tested month

        if (dtThis.Day != dayOfMonth) //Example 30 Jan 2013 will go to 28 Feb when a month is added, so when it goes to march it will be 28th and not 30th
        {
            if (daysinMonth < dayOfMonth) // uses day in month max if can't set back to day of month
                dtThis.AddDays(daysinMonth - dtThis.Day);
            else
                dtThis.AddDays(dayOfMonth - dtThis.Day);
        }
        if (((dtOther.Year == dtThis.Year) && (dtOther.Month == dtThis.Month))) //If the loop puts it in the same month and year
        {
            if (dtOther.Day >= dayOfMonth) //check to see if it is the same day or later to add one to month
                intReturn++;
            sameMonth = true; //sets this to cancel out of the normal counting of month
        }
        if ((!sameMonth)&&(dtOther.Date > dtThis.Date))//so as long as it didn't reach the same month (or if i started in the same month, one month ahead, add a month)
            intReturn++;
    }
    return intReturn; //return month
}

नीचे वास्तव में यह सबसे सटीक तरीका है कि आप इसे कर सकते हैं, क्योंकि "1 महीने" की परिभाषा किस महीने के आधार पर बदलती है, और अन्य उत्तरों में से कोई भी इसे ध्यान में रखता है! यदि आप इस मुद्दे के बारे में अधिक जानकारी चाहते हैं जो ढांचे में नहीं बनाया गया है, तो आप इस पोस्ट को पढ़ सकते हैं: एक वास्तविक टाइम्सपैन ऑब्जेक्ट के साथ। प्रिय और। हालांकि, उस पोस्ट को पढ़ने और नीचे दिए गए फ़ंक्शन का उपयोग करने के लिए आवश्यक नहीं है, यह 100% काम करता है, अनुमानित अन्य अंतर्निहित त्रुटियों के बिना दूसरों को उपयोग करना पसंद है - और इसे बदलने के लिए स्वतंत्र महसूस करें। अंतर्निहित कार्य के साथ यह कार्य करें। आपके फ्रेमवर्क पर जो भी कार्य हो सकता है (यह सिर्फ पूर्णता के लिए है)।

कृपया ध्यान दें कि आप किसी भी तारीख / समय सटीकता, सेकंड और मिनट, या सेकंड, मिनट और दिन, कहीं भी वर्षों तक प्राप्त कर सकते हैं (जिसमें 6 भाग / सेगमेंट होंगे)। यदि आप शीर्ष दो निर्दिष्ट करते हैं और यह एक वर्ष से अधिक पुराना है, तो यह "1 वर्ष और 3 महीने पहले" वापस आ जाएगा और बाकी को वापस नहीं करेगा क्योंकि आपने दो सेगमेंट का अनुरोध किया है। अगर यह केवल कुछ घंटों पुराना है, तो यह केवल "2 घंटे और 1 मिनट पहले" वापस आ जाएगा। बेशक, यदि आप 1, 2, 3, 4, 5 या 6 सेगमैट निर्दिष्ट करते हैं (सेकेंड, मिनट, घंटे, दिन, महीने, साल केवल 6 प्रकार बनाते हैं) पर समान नियम लागू होते हैं। यह "मिनट" बनाम "मिनट" जैसे व्याकरण संबंधी मुद्दों को भी सही करेगा, यदि यह 1 मिनट या उससे अधिक है, तो सभी प्रकार के लिए समान है, और उत्पन्न "स्ट्रिंग" हमेशा व्याकरणिक रूप से सही होगा।

यहां उपयोग के लिए कुछ उदाहरण दिए गए हैं: bAllowSegments यह दर्शाता है कि कितने सेगमेंट दिखाना है ... यानी: यदि 3, तो स्ट्रिंग स्ट्रिंग (उदाहरण के रूप में) ... "3 years, 2 months and 13 days" (इसमें शामिल नहीं होगा घंटे, मिनट और सेकंड शीर्ष 3 बार श्रेणियों के रूप में लौटाए जाते हैं), यदि, हालांकि, तारीख एक नई तारीख थी, जैसे कि कुछ दिन पहले, उसी सेगमेंट निर्दिष्ट करना (3) "4 days, 1 hour and 13 minutes ago" लौटाएगा "4 days, 1 hour and 13 minutes ago" इसके बजाय, यह सब कुछ ध्यान में रखता है!

यदि bAllowSegments 2 है तो यह "3 years and 2 months" वापस आ जाएगा और यदि 6 (अधिकतम मूल्य) "3 years, 2 months, 13 days, 13 hours, 29 minutes and 9 seconds" लौटाएगा, लेकिन, याद दिलाया जाए कि यह होगा इस "0 years, 0 months, 0 days, 3 hours, 2 minutes and 13 seconds ago" जैसे कुछ NEVER RETURN न करें क्योंकि यह समझता है कि शीर्ष 3 खंडों में कोई दिनांक डेटा नहीं है और उन्हें अनदेखा करता है, भले ही आप 6 सेगमेंट निर्दिष्ट करते हैं, डोंट वोर्री :)। बेशक, यदि 0 में सेगमेंट है, तो स्ट्रिंग बनाने के दौरान यह ध्यान में रखेगा, और "3 days and 4 seconds ago" रूप में प्रदर्शित होगा "3 days and 4 seconds ago" "0 घंटे" भाग को अनदेखा कर देगा! आनंद लें और अगर आप चाहें तो टिप्पणी करें।

 Public Function RealTimeUntilNow(ByVal dt As DateTime, Optional ByVal bAllowSegments As Byte = 2) As String
  ' bAllowSegments identifies how many segments to show... ie: if 3, then return string would be (as an example)...
  ' "3 years, 2 months and 13 days" the top 3 time categories are returned, if bAllowSegments is 2 it would return
  ' "3 years and 2 months" and if 6 (maximum value) would return "3 years, 2 months, 13 days, 13 hours, 29 minutes and 9 seconds"
  Dim rYears, rMonths, rDays, rHours, rMinutes, rSeconds As Int16
  Dim dtNow = DateTime.Now
  Dim daysInBaseMonth = Date.DaysInMonth(dt.Year, dt.Month)

  rYears = dtNow.Year - dt.Year
  rMonths = dtNow.Month - dt.Month
  If rMonths < 0 Then rMonths += 12 : rYears -= 1 ' add 1 year to months, and remove 1 year from years.
  rDays = dtNow.Day - dt.Day
  If rDays < 0 Then rDays += daysInBaseMonth : rMonths -= 1
  rHours = dtNow.Hour - dt.Hour
  If rHours < 0 Then rHours += 24 : rDays -= 1
  rMinutes = dtNow.Minute - dt.Minute
  If rMinutes < 0 Then rMinutes += 60 : rHours -= 1
  rSeconds = dtNow.Second - dt.Second
  If rSeconds < 0 Then rSeconds += 60 : rMinutes -= 1

  ' this is the display functionality
  Dim sb As StringBuilder = New StringBuilder()
  Dim iSegmentsAdded As Int16 = 0

  If rYears > 0 Then sb.Append(rYears) : sb.Append(" year" & If(rYears <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rMonths > 0 Then sb.AppendFormat(rMonths) : sb.Append(" month" & If(rMonths <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rDays > 0 Then sb.Append(rDays) : sb.Append(" day" & If(rDays <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rHours > 0 Then sb.Append(rHours) : sb.Append(" hour" & If(rHours <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rMinutes > 0 Then sb.Append(rMinutes) : sb.Append(" minute" & If(rMinutes <> 1, "s", "") & ", ") : iSegmentsAdded += 1
  If bAllowSegments = iSegmentsAdded Then GoTo parseAndReturn

  If rSeconds > 0 Then sb.Append(rSeconds) : sb.Append(" second" & If(rSeconds <> 1, "s", "") & "") : iSegmentsAdded += 1

parseAndReturn:

  ' if the string is entirely empty, that means it was just posted so its less than a second ago, and an empty string getting passed will cause an error
  ' so we construct our own meaningful string which will still fit into the "Posted * ago " syntax...

  If sb.ToString = "" Then sb.Append("less than 1 second")

  Return ReplaceLast(sb.ToString.TrimEnd(" ", ",").ToString, ",", " and")

 End Function

बेशक, आपको एक "रीप्लेसलास्ट" फ़ंक्शन की आवश्यकता होगी, जो एक स्रोत स्ट्रिंग लेता है, और एक तर्क जो निर्दिष्ट करने की आवश्यकता है, और एक अन्य तर्क निर्दिष्ट करता है कि आप इसे किस स्थान से बदलना चाहते हैं, और यह केवल उस स्ट्रिंग के अंतिम अवसर को प्रतिस्थापित करता है ... अगर मैंने आपके पास कोई नहीं है या इसे लागू नहीं करना चाहते हैं, तो मैंने अपना एक शामिल किया है, इसलिए यहां यह है कि यह "जैसा है" काम करेगा, जिसमें कोई संशोधन आवश्यक नहीं है। मुझे पता है कि रिवर्सिट फ़ंक्शन की आवश्यकता नहीं है (.NET में मौजूद है) लेकिन ReplaceLast और ReverseIt func को प्री-नेटवर्क्स दिनों से लिया जाता है, इसलिए कृपया यह बताएं कि यह कितना दिनांकित हो सकता है (अभी भी 100% काम करता है, इसका उपयोग कर रहा है दस साल से अधिक के लिए, गारंटी दे सकते हैं कि वे बग मुक्त हैं) ... :)। खुश होती है।

<Extension()> _ 
Public Function ReplaceLast(ByVal sReplacable As String, ByVal sReplaceWhat As String, ByVal sReplaceWith As String) As String 
    ' let empty string arguments run, incase we dont know if we are sending and empty string or not. 
    sReplacable = sReplacable.ReverseIt 
    sReplacable = Replace(sReplacable, sReplaceWhat.ReverseIt, sReplaceWith.ReverseIt, , 1) ' only does first item on reversed version! 
    Return sReplacable.ReverseIt.ToString 
End Function 

<Extension()> _ 
Public Function ReverseIt(ByVal strS As String, Optional ByVal n As Integer = -1) As String 
    Dim strTempX As String = "", intI As Integer 

    If n > strS.Length Or n = -1 Then n = strS.Length 

    For intI = n To 1 Step -1 
        strTempX = strTempX + Mid(strS, intI, 1) 
    Next intI 

    ReverseIt = strTempX + Right(strS, Len(strS) - n) 

End Function 

पुराना सवाल मुझे पता है, लेकिन किसी की मदद कर सकता है। मैंने उपरोक्त @ एडम स्वीकृत उत्तर का उपयोग किया है, लेकिन फिर जांच की गई है कि अंतर 1 या -1 है, तो यह देखने के लिए जांचें कि यह एक पूर्ण कैलेंडर माह का अंतर है या नहीं। तो 21/07/55 और 20/08/55 एक पूर्ण महीना नहीं होगा, लेकिन 21/07/55 और 21/07/55 होगा।

/// <summary>
/// Amended date of birth cannot be greater than or equal to one month either side of original date of birth.
/// </summary>
/// <param name="dateOfBirth">Date of birth user could have amended.</param>
/// <param name="originalDateOfBirth">Original date of birth to compare against.</param>
/// <returns></returns>
public JsonResult ValidateDateOfBirth(string dateOfBirth, string originalDateOfBirth)
{
    DateTime dob, originalDob;
    bool isValid = false;

    if (DateTime.TryParse(dateOfBirth, out dob) && DateTime.TryParse(originalDateOfBirth, out originalDob))
    {
        int diff = ((dob.Month - originalDob.Month) + 12 * (dob.Year - originalDob.Year));

        switch (diff)
        {
            case 0:
                // We're on the same month, so ok.
                isValid = true;
                break;
            case -1:
                // The month is the previous month, so check if the date makes it a calendar month out.
                isValid = (dob.Day > originalDob.Day);
                break;
            case 1:
                // The month is the next month, so check if the date makes it a calendar month out.
                isValid = (dob.Day < originalDob.Day);
                break;
            default:
                // Either zero or greater than 1 month difference, so not ok.
                isValid = false;
                break;
        }
        if (!isValid)
            return Json("Date of Birth cannot be greater than one month either side of the date we hold.", JsonRequestBehavior.AllowGet);
    }
    else
    {
        return Json("Date of Birth is invalid.", JsonRequestBehavior.AllowGet);
    }
    return Json(true, JsonRequestBehavior.AllowGet);
}

महीनों में अंतर पाने के लिए मेरा योगदान यहां दिया गया है जो मुझे सटीक पाया गया है:

namespace System
{
     public static class DateTimeExtensions
     {
         public static Int32 DiffMonths( this DateTime start, DateTime end )
         {
             Int32 months = 0;
             DateTime tmp = start;

             while ( tmp < end )
             {
                 months++;
                 tmp = tmp.AddMonths( 1 );
             }

             return months;
        }
    }
}

उपयोग:

Int32 months = DateTime.Now.DiffMonths( DateTime.Now.AddYears( 5 ) );

आप डिफयर्स नामक एक और विधि बना सकते हैं और जबकि लूप में AddMonths के बजाय उपरोक्त और addYears के समान बिल्कुल तर्क लागू कर सकते हैं।


मैं इसे इस तरह करूँगा:

static int TotelMonthDifference(this DateTime dtThis, DateTime dtOther)
{
    int intReturn = 0;

    dtThis = dtThis.Date.AddDays(-(dtThis.Day-1));
    dtOther = dtOther.Date.AddDays(-(dtOther.Day-1));

    while (dtOther.Date > dtThis.Date)
    {
        intReturn++;     
        dtThis = dtThis.AddMonths(1);
    }

    return intReturn;
}

यदि आप 28th Feb और 1st March बीच परिणाम 1 चाहते हैं:

DateTime date1, date2;
int monthSpan = (date2.Year - date1.Year) * 12 + date2.Month - date1.Month

यदि आप महीनों और वर्षों से निपट रहे हैं तो आपको कुछ ऐसा चाहिए जो जानता है कि प्रत्येक महीने कितने दिन हैं और कौन सा साल लीप साल हैं।

ग्रेगोरियन कैलेंडर (और अन्य संस्कृति-विशिष्ट Calendar कार्यान्वयन) दर्ज करें।

जबकि कैलेंडर समय में दो बिंदुओं के बीच अंतर की गणना करने के तरीकों को प्रदान नहीं करता है, इसमें विधियां भी हैं

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

विधि एक सूची देता है जिसमें 3 तत्व पहले वर्ष होता है, दूसरा महीना होता है और अंत तत्व दिन होता है:

public static List<int> GetDurationInEnglish(DateTime from, DateTime to)
    {
        try
        {
            if (from > to)
                return null;

            var fY = from.Year;
            var fM = from.Month;
            var fD = DateTime.DaysInMonth(fY, fM);

            var tY = to.Year;
            var tM = to.Month;
            var tD = DateTime.DaysInMonth(tY, tM);

            int dY = 0;
            int dM = 0;
            int dD = 0;

            if (fD > tD)
            {
                tM--;

                if (tM <= 0)
                {
                    tY--;
                    tM = 12;
                    tD += DateTime.DaysInMonth(tY, tM);
                }
                else
                {
                    tD += DateTime.DaysInMonth(tY, tM);
                }
            }
            dD = tD - fD;

            if (fM > tM)
            {
                tY--;

                tM += 12;
            }
            dM = tM - fM;

            dY = tY - fY;

            return new List<int>() { dY, dM, dD };
        }
        catch (Exception exception)
        {
            //todo: log exception with parameters in db

            return null;
        }
    }

शायद आप महीने के अंशों के बारे में जानना नहीं चाहते हैं; इस कोड के बारे में क्या?


public static class DateTimeExtensions
{
    public static int TotalMonths(this DateTime start, DateTime end)
    {
        return (start.Year * 12 + start.Month) - (end.Year * 12 + end.Month);
    }
}

//  Console.WriteLine(
//     DateTime.Now.TotalMonths(
//         DateTime.Now.AddMonths(-1))); // prints "1"



http://www.astro.uu.nl/~strous/AA/en/reken/juliaansedag.html

यदि आप ग्रेगोरियन डेट से जूलियन दिन संख्या में परिवर्तित समय प्राप्त कर सकते हैं, तो आप ज़ुलियन दिन संख्या की तुलना करने के लिए केवल एक ऑपरेटर बना सकते हैं, जिसे महीनों, दिन, सेकंड आदि प्राप्त करने के लिए डबल टाइप किया जा सकता है। उपर्युक्त देखें ग्रेगोरियन से जूलियन में परिवर्तित करने के लिए एल्गोरिदम के लिए लिंक।


This लाइब्रेरी डेटटाइम के सभी हिस्सों पर विचार करते हुए महीनों के अंतर की गणना करती है:

// ----------------------------------------------------------------------
public void DateDiffSample()
{
  DateTime date1 = new DateTime( 2009, 11, 8, 7, 13, 59 );
  Console.WriteLine( "Date1: {0}", date1 );
  // > Date1: 08.11.2009 07:13:59
  DateTime date2 = new DateTime( 2011, 3, 20, 19, 55, 28 );
  Console.WriteLine( "Date2: {0}", date2 );
  // > Date2: 20.03.2011 19:55:28

  DateDiff dateDiff = new DateDiff( date1, date2 );

  // differences
  Console.WriteLine( "DateDiff.Years: {0}", dateDiff.Years );
  // > DateDiff.Years: 1
  Console.WriteLine( "DateDiff.Quarters: {0}", dateDiff.Quarters );
  // > DateDiff.Quarters: 5
  Console.WriteLine( "DateDiff.Months: {0}", dateDiff.Months );
  // > DateDiff.Months: 16
  Console.WriteLine( "DateDiff.Weeks: {0}", dateDiff.Weeks );
  // > DateDiff.Weeks: 70
  Console.WriteLine( "DateDiff.Days: {0}", dateDiff.Days );
  // > DateDiff.Days: 497
  Console.WriteLine( "DateDiff.Weekdays: {0}", dateDiff.Weekdays );
  // > DateDiff.Weekdays: 71
  Console.WriteLine( "DateDiff.Hours: {0}", dateDiff.Hours );
  // > DateDiff.Hours: 11940
  Console.WriteLine( "DateDiff.Minutes: {0}", dateDiff.Minutes );
  // > DateDiff.Minutes: 716441
  Console.WriteLine( "DateDiff.Seconds: {0}", dateDiff.Seconds );
  // > DateDiff.Seconds: 42986489

  // elapsed
  Console.WriteLine( "DateDiff.ElapsedYears: {0}", dateDiff.ElapsedYears );
  // > DateDiff.ElapsedYears: 1
  Console.WriteLine( "DateDiff.ElapsedMonths: {0}", dateDiff.ElapsedMonths );
  // > DateDiff.ElapsedMonths: 4
  Console.WriteLine( "DateDiff.ElapsedDays: {0}", dateDiff.ElapsedDays );
  // > DateDiff.ElapsedDays: 12
  Console.WriteLine( "DateDiff.ElapsedHours: {0}", dateDiff.ElapsedHours );
  // > DateDiff.ElapsedHours: 12
  Console.WriteLine( "DateDiff.ElapsedMinutes: {0}", dateDiff.ElapsedMinutes );
  // > DateDiff.ElapsedMinutes: 41
  Console.WriteLine( "DateDiff.ElapsedSeconds: {0}", dateDiff.ElapsedSeconds );
  // > DateDiff.ElapsedSeconds: 29
} // DateDiffSample

DateTime start = new DateTime(2003, 12, 25);
DateTime end = new DateTime(2009, 10, 6);
int compMonth = (end.Month + end.Year * 12) - (start.Month + start.Year * 12);
double daysInEndMonth = (end - end.AddMonths(1)).Days;
double months = compMonth + (start.Day - end.Day) / daysInEndMonth;

case TipoIntervalo.Mes:
    retorno = inicio.AddMonths(-fim.Month).Month.ToString();
    break;
case TipoIntervalo.Ano:
    retorno = (inicio.Year - fim.Year).ToString();
    break;




timespan