ı want to calculate different between two date?

private void CalculateDifference()
{
    int years, months, days;

    years = (dateTimePicker2.Value.Year - dateTimePicker1.Value.Year);
    months = (dateTimePicker2.Value.Month - dateTimePicker1.Value.Month);
    days = (dateTimePicker2.Value.Day - dateTimePicker1.Value.Day);
    
    if (months < 0)
    {
        years--;
        months = months + 12;
    }

    if (days < 0)
    {
        months--;
        days = days + 30;
    }

    textBox1.Text = years + " Years, " + months + " Months, " + days + " Days";
}

This gives the following results for the following inputs

First Date	Second Date	Date Difference
10.07.2009	07.07.2010	0 Years, 9 Months, 0 Days
10.07.2009	10.08.2010	1 Years, 0 Months, 1 Days
12.16.2009	10.08.2010	0 Years, 9 Months, 22 Days
06.08.2009	07.07.2010	0 Years, 0 Months, 29 Days
02.07.2010	03.04.2010	0 Years, 0 Months, 27 Days*

*The last example is actually inaccurate, though, because February does not have 30 days. In actuality, the difference between March 4th and February 7th is 25 days on a non-leap year and 26 on a leap year, not 27. But that's what you asked for.

Basically you have/want to create a custom calendar for an year that has 12 months each having 30 days.

Since the requirement is not a normal date manipulations where Feb can have 28 or 29 and few other months 31... you have to create your own DateClass that can handle such operations.

In the class, define normal date manipulations you want to have.
Your logic would be based on 12*30 = 360 days in an year. (30 days equally distributed across the year for each month)

Further, this custom class would help you in your datepicker too. As currently, none of the datepicker just shows 30 days for each month.
Strange requirement, you need to create something new for yourself.

This is a very strange requirement and some explanation of why it's required could lead to a better answer.

Anyway, taking your question as you have posed it, you will need a custom struct. System.DateTime is basically a wrapper around a long that represents the number of ticks since 1st Jan 0001. You need to do something similar. As you only need day and not tick precision I would suggest wrapping an int. once that is done the rest is fairly standard stuff.

I have coded (not tested) a basic sample [because I found the problem sort of interesting] that meets your requirements except how the span is displayed - you can call GetDaySpan and use some math on the result to get what you want. There is a lot of optimisation that could be done but I leave that up to you too.

Enjoy...

public struct WierdDate
{
    public const int DaysPerMonth = 30;
    public const int DaysPerYear = DaysPerMonth * MonthsPerYear;
    public const int MaxYear = 9999;
    public const int MonthsPerYear = 12;
    public static readonly WierdDate MaxWierdDate = new WierdDate(DaysPerMonth, MonthsPerYear, MaxYear);
    public static readonly WierdDate MinWierdDate = new WierdDate();
    private int days;
    private WierdDate(int days)
    {
        this.days = days;
    }
    public WierdDate(int day, int month, int year)
    {
        if (day < 1 || day > DaysPerMonth)
            throw new ArgumentOutOfRangeException("day", string.Format("day must be between 1 and {0}", DaysPerMonth));
        if (month < 1 || month > MonthsPerYear)
            throw new ArgumentOutOfRangeException("month", string.Format("month must be between 1 and {0}", MonthsPerYear));
        if (year < 1 || year > MaxYear)
            throw new ArgumentOutOfRangeException("year", string.Format("year must be between 1 and {0}", MaxYear));
        days = ((year - 1) * DaysPerYear) + ((month - 1) * DaysPerMonth) + (day - 1);
    }
    public static bool operator ==(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return wierdDateA.days == wierdDateB.days;
    }
    public static bool operator !=(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return !(wierdDateA == wierdDateB);
    }
    public static WierdDate operator ++(WierdDate wierdDate)
    {
        return wierdDate + 1;
    }
    public static WierdDate operator --(WierdDate wierdDate)
    {
        return wierdDate - 1;
    }
    public static WierdDate operator +(WierdDate wierdDate, int value)
    {
        return new WierdDate(wierdDate.days + value);
    }
    public static WierdDate operator -(WierdDate wierdDate, int value)
    {
        return new WierdDate(wierdDate.days - value);
    }
    public static bool operator >(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return wierdDateA.days > wierdDateB.days;
    }
    public static bool operator <(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return wierdDateA.days < wierdDateB.days;
    }
    public static bool operator >=(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return wierdDateA.days >= wierdDateB.days;
    }
    public static bool operator <=(WierdDate wierdDateA, WierdDate wierdDateB)
    {
        return wierdDateA.days <= wierdDateB.days;
    }
    public int Day
    {
        get { return (TotalDays - (TotalMonths * DaysPerMonth)) + 1; }
    }
    public int Month
    {
        get { return (TotalMonths - (TotalYears * MonthsPerYear)) + 1; }
    }
    public int Year
    {
        get { return TotalYears + 1; }
    }
    public int TotalDays
    {
        get { return days; }
    }
    public int TotalMonths
    {
        get { return (days / DaysPerMonth); }
    }
    public int TotalYears
    {
        get { return days / DaysPerYear; }
    }
    public int GetDaySpan(WierdDate other)
    {
        return other.days - days;
    }
    public override bool Equals(object obj)
    {
        return obj is WierdDate && ((WierdDate)obj) == this;
    }
    public override int GetHashCode()
    {
        return days.GetHashCode();
    }
    public override string ToString()
    {
        return string.Format("Day: {0}, Month: {1}, Year: {2}", Day, Month, Year);
    }
}

So February 28th & 29th doesn't matter.

Tell that to the people born on those days.


but all months must be 30 days

Ummm, this isn't actually true. Some months have 30 days, and some have 31, and then there's that pesky February that you've already discounted. Are you now going to tell us that a solar year consists of fewer than 365 days?

Date math is a simple process in .Net. Just subtract the dates from each other into a TimeSpan object and play to your heart's content. How freakin' hard can it be?