C# DateTime and TimeSpan: Now, UtcNow, Add, Subtract, Compare and Parse

System.DateTime represents a date and a time of day, from year 1 to year 9999, with a precision of 100 nanoseconds (one "tick"). System.TimeSpan represents a duration: the difference between two DateTime values. Both are immutable value types (structs), so every operation returns a new value.

using System;

class Program
{
    static void Main()
    {
        var launch = new DateTime(2026, 9, 24);                 // midnight
        var meeting = new DateTime(2026, 9, 24, 14, 30, 0);     // 14:30:00
        var precise = new DateTime(2026, 9, 24, 14, 30, 5, 250); // with milliseconds

        Console.WriteLine(launch.ToString("yyyy-MM-dd HH:mm:ss"));
        Console.WriteLine(meeting.ToString("yyyy-MM-dd HH:mm:ss"));
        Console.WriteLine(precise.ToString("HH:mm:ss.fff"));

        Console.WriteLine($"{meeting.Year} {meeting.Month} {meeting.Day}");
        Console.WriteLine($"{meeting.Hour}:{meeting.Minute}");
        Console.WriteLine(meeting.DayOfWeek);
        Console.WriteLine(meeting.DayOfYear);
        Console.WriteLine(meeting.Date.ToString("yyyy-MM-dd HH:mm")); // time set to 00:00
        Console.WriteLine(meeting.TimeOfDay);                          // a TimeSpan
    }
}

Output:

2026-09-24 00:00:00
2026-09-24 14:30:00
14:30:05.250
2026 9 24
14:30
Thursday
267
2026-09-24 00:00
14:30:00

Every example on this page prints dates with an explicit format string. The default ToString() follows the current culture (9/24/2026 2:30:00 PM in the US, 24.09.2026 14:30:00 in Germany), so its output depends on the machine. The format codes are on DateTime format.

An invalid date throws: new DateTime(2026, 2, 30) raises an ArgumentOutOfRangeException, as does month 13 or hour 24.

Now, UtcNow and Today

Three static properties read the clock:

using System;

class Program
{
    static void Main()
    {
        DateTime local = DateTime.Now;      // local time zone
        DateTime utc = DateTime.UtcNow;     // Coordinated Universal Time
        DateTime today = DateTime.Today;    // local date, time 00:00:00

        Console.WriteLine($"Now:    {local:yyyy-MM-dd HH:mm:ss} ({local.Kind})");
        Console.WriteLine($"UtcNow: {utc:yyyy-MM-dd HH:mm:ss} ({utc.Kind})");
        Console.WriteLine($"Today:  {today:yyyy-MM-dd HH:mm:ss}");
    }
}

Example output:

Now:    2026-09-24 18:20:41 (Local)
UtcNow: 2026-09-24 16:20:41 (Utc)
Today:  2026-09-24 00:00:00

In this example the local time zone is two hours ahead of UTC, so the first two lines differ by two hours; on a machine set to UTC they match. The Kind property records whether a value is Local, Utc or Unspecified (the default for dates you construct yourself). Use DateTime.UtcNow for anything you store, log, compare or send to another system: it does not jump when daylight saving time starts or ends, and it means the same moment on every server. Convert to local time only when showing a value to a person.

To measure how long code takes, use System.Diagnostics.Stopwatch rather than subtracting two DateTime.Now values; it has much finer resolution and is not affected by clock adjustments.

Adding and subtracting time

AddDays, AddHours, AddMinutes, AddSeconds, AddMonths and AddYears return a new DateTime. Pass a negative number to go back. Because DateTime is immutable, the result must be assigned:

using System;

class Program
{
    static void Main()
    {
        var ordered = new DateTime(2026, 1, 31, 9, 0, 0);

        ordered.AddDays(3);                     // result discarded: no effect
        Console.WriteLine(ordered.ToString("yyyy-MM-dd"));

        DateTime shipped = ordered.AddDays(3);
        DateTime reminder = ordered.AddHours(-12);
        DateTime renewal = ordered.AddMonths(1);  // Jan 31 + 1 month
        DateTime nextYear = ordered.AddYears(1);

        Console.WriteLine(shipped.ToString("yyyy-MM-dd HH:mm"));
        Console.WriteLine(reminder.ToString("yyyy-MM-dd HH:mm"));
        Console.WriteLine(renewal.ToString("yyyy-MM-dd"));
        Console.WriteLine(nextYear.ToString("yyyy-MM-dd"));

        DateTime later = ordered + TimeSpan.FromMinutes(90);  // + a TimeSpan
        Console.WriteLine(later.ToString("HH:mm"));

        Console.WriteLine(DateTime.DaysInMonth(2028, 2));
        Console.WriteLine(DateTime.IsLeapYear(2028));
    }
}

Output:

2026-01-31
2026-02-03 09:00
2026-01-30 21:00
2026-02-28
2027-01-31
10:30
29
True

AddMonths clamps to the last day of the month when the day does not exist: January 31 plus one month is February 28 (or 29 in a leap year), not March 3. Adding one month twice and adding two months can therefore give different dates.

Subtracting dates: TimeSpan

Subtracting one DateTime from another gives a TimeSpan:

using System;

class Program
{
    static void Main()
    {
        var checkIn = new DateTime(2026, 9, 20, 15, 0, 0);
        var checkOut = new DateTime(2026, 9, 24, 11, 30, 0);

        TimeSpan stay = checkOut - checkIn;

        Console.WriteLine(stay);                         // d.hh:mm:ss
        Console.WriteLine($"Days: {stay.Days}, Hours: {stay.Hours}, Minutes: {stay.Minutes}");
        Console.WriteLine($"TotalDays: {stay.TotalDays:F2}");
        Console.WriteLine($"TotalHours: {stay.TotalHours}");
        Console.WriteLine($"TotalMinutes: {stay.TotalMinutes}");

        int nights = (checkOut.Date - checkIn.Date).Days;   // calendar days
        Console.WriteLine($"Nights: {nights}");
    }
}

Output:

3.20:30:00
Days: 3, Hours: 20, Minutes: 30
TotalDays: 3.85
TotalHours: 92.5
TotalMinutes: 5550
Nights: 4

This is the part of the API people get wrong most often. Days, Hours, Minutes and Seconds are the components of the span (3 days, 20 hours, 30 minutes). TotalDays, TotalHours and TotalMinutes are the whole duration in one unit, as a double. "How many hours did the guest stay?" is TotalHours (92.5), not Hours (20).

The last line shows a related point: 3.85 days elapsed, but the guest stayed 4 nights. Comparing the .Date parts counts calendar days, which is usually what billing and "days until" displays want.

Creating and formatting TimeSpan values

using System;

class Program
{
    static void Main()
    {
        TimeSpan a = TimeSpan.FromMinutes(135);
        TimeSpan b = new TimeSpan(1, 30, 0);          // hours, minutes, seconds
        TimeSpan c = TimeSpan.FromDays(1.5);
        TimeSpan d = TimeSpan.Parse("02:15:00");

        Console.WriteLine(a);
        Console.WriteLine(b);
        Console.WriteLine(c);
        Console.WriteLine(a == d);
        Console.WriteLine(a + b);
        Console.WriteLine(a > b);
        Console.WriteLine(a.ToString(@"hh\:mm"));
        Console.WriteLine($"{(int)c.TotalHours}h {c.Minutes}m");
        Console.WriteLine(TimeSpan.Zero);
    }
}

Output:

02:15:00
01:30:00
1.12:00:00
True
03:45:00
True
02:15
36h 0m
00:00:00

TimeSpan supports +, -, comparisons, Duration() (absolute value) and Negate(). Custom formats such as @"hh\:mm" need a backslash before literal characters, and hh there shows only the hours component (0 to 23), so for durations over a day, build the text from TotalHours as in the second to last line.

Comparing dates

DateTime supports ==, !=, <, >, <= and >=, plus CompareTo and DateTime.Compare. To compare only the date and ignore the time, compare the .Date properties:

using System;

class Program
{
    static void Main()
    {
        var deadline = new DateTime(2026, 10, 1, 17, 0, 0);
        var submitted = new DateTime(2026, 10, 1, 18, 45, 0);

        Console.WriteLine(submitted > deadline);            // late by time
        Console.WriteLine(submitted.Date == deadline.Date); // same day
        Console.WriteLine(DateTime.Compare(submitted, deadline)); // 1: later

        var start = new DateTime(2026, 9, 1);
        var end = new DateTime(2026, 9, 30);
        var check = new DateTime(2026, 9, 24, 12, 0, 0);
        Console.WriteLine(check >= start && check < end.AddDays(1));   // in range, inclusive of the end day

        DateTime earliest = start < check ? start : check;
        Console.WriteLine(earliest.ToString("yyyy-MM-dd"));
    }
}

Output:

True
True
1
True
2026-09-01

For "is this timestamp within September 30?", compare against the start of the next day with <, as above. Writing check <= end would exclude everything after midnight on the last day, because end is 2026-09-30 00:00:00.

Comparisons look only at the ticks, not at Kind: a Local value and a Utc value that print the same are considered equal even though they are different moments. Another reason to keep stored times in UTC.

Day of week and start of week

DayOfWeek is an enum from Sunday (0) to Saturday (6). Arithmetic on it finds weekdays and week boundaries:

using System;

class Program
{
    static void Main()
    {
        var date = new DateTime(2026, 9, 24);
        Console.WriteLine(date.DayOfWeek);
        Console.WriteLine((int)date.DayOfWeek);

        bool weekend = date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;
        Console.WriteLine($"Weekend: {weekend}");

        // Monday of the same week
        int sinceMonday = ((int)date.DayOfWeek + 6) % 7;
        DateTime monday = date.AddDays(-sinceMonday);
        Console.WriteLine($"Week starts {monday:yyyy-MM-dd} ({monday.DayOfWeek})");

        // Next Friday (today counts if it is Friday)
        int toFriday = ((int)DayOfWeek.Friday - (int)date.DayOfWeek + 7) % 7;
        Console.WriteLine($"Next Friday: {date.AddDays(toFriday):yyyy-MM-dd}");

        // First and last day of the month
        var first = new DateTime(date.Year, date.Month, 1);
        var last = first.AddMonths(1).AddDays(-1);
        Console.WriteLine($"{first:yyyy-MM-dd} to {last:yyyy-MM-dd}");
    }
}

Output:

Thursday
4
Weekend: False
Week starts 2026-09-21 (Monday)
Next Friday: 2026-09-25
2026-09-01 to 2026-09-30

The day names printed by DayOfWeek.ToString() are always English. For a localized name, format the date with "dddd" and a culture.

Parsing dates from strings

When you know the format of the input, use ParseExact or TryParseExact with CultureInfo.InvariantCulture. The format string uses the same codes as formatting:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;

        DateTime a = DateTime.ParseExact("2026-09-24", "yyyy-MM-dd", inv);
        DateTime b = DateTime.ParseExact("24/09/2026 18:05", "dd/MM/yyyy HH:mm", inv);
        Console.WriteLine(a.ToString("yyyy-MM-dd HH:mm"));
        Console.WriteLine(b.ToString("yyyy-MM-dd HH:mm"));

        string[] inputs = { "2026-02-28", "2026-02-30", "28.02.2026", "" };
        foreach (string text in inputs)
        {
            if (DateTime.TryParseExact(text, "yyyy-MM-dd", inv, DateTimeStyles.None, out DateTime d))
                Console.WriteLine($"'{text}' -> {d:dddd, MMMM d}");
            else
                Console.WriteLine($"'{text}' -> invalid");
        }

        // Several accepted formats
        string[] formats = { "yyyy-MM-dd", "dd.MM.yyyy", "MM/dd/yyyy" };
        DateTime c = DateTime.ParseExact("28.02.2026", formats, inv, DateTimeStyles.None);
        Console.WriteLine(c.ToString("yyyy-MM-dd"));

        // ISO 8601 with an offset or Z
        DateTime utc = DateTime.Parse("2026-09-24T10:00:00Z", inv, DateTimeStyles.AdjustToUniversal);
        Console.WriteLine($"{utc:yyyy-MM-dd HH:mm} {utc.Kind}");
    }
}

Output:

2026-09-24 00:00
2026-09-24 18:05
'2026-02-28' -> Saturday, February 28
'2026-02-30' -> invalid
'28.02.2026' -> invalid
'' -> invalid
2026-02-28
2026-09-24 10:00 Utc

DateTime.Parse(text) without a format tries to guess using the current culture. "03/04/2026" is March 4 on a US machine and April 3 on a British one, and a date that parses on your laptop can throw a FormatException on a server. Keep Parse for input typed by a local user; use ParseExact with the invariant culture for files, APIs and databases. ParseExact throws FormatException when the text does not match; TryParseExact returns false instead.

Calculating an age

Subtracting birth dates and dividing by 365 is wrong around birthdays and leap years. Compare years, then correct if this year's birthday has not happened yet:

using System;

class Program
{
    static int Age(DateTime birth, DateTime today)
    {
        int age = today.Year - birth.Year;
        if (birth.Date > today.AddYears(-age)) age--;   // birthday not reached yet this year
        return age;
    }

    static void Main()
    {
        var today = new DateTime(2026, 9, 24);
        Console.WriteLine(Age(new DateTime(1990, 9, 24), today));  // birthday today
        Console.WriteLine(Age(new DateTime(1990, 9, 25), today));  // tomorrow
        Console.WriteLine(Age(new DateTime(2008, 2, 29), today));  // leap day

        var nextBirthday = new DateTime(today.Year, 12, 3);
        if (nextBirthday < today) nextBirthday = nextBirthday.AddYears(1);
        Console.WriteLine($"{(nextBirthday - today).Days} days to go");
    }
}

Output:

36
35
18
70 days to go

DateTimeOffset

A DateTime does not record which time zone it is in beyond the vague Kind flag. DateTimeOffset stores the value together with its offset from UTC, so it always identifies one exact moment:

using System;

class Program
{
    static void Main()
    {
        var placed = new DateTimeOffset(2026, 9, 24, 14, 0, 0, TimeSpan.FromHours(2));   // UTC+2
        var received = new DateTimeOffset(2026, 9, 24, 8, 30, 0, TimeSpan.FromHours(-4)); // UTC-4

        Console.WriteLine(placed.ToString("yyyy-MM-dd HH:mm zzz"));
        Console.WriteLine(placed.UtcDateTime.ToString("yyyy-MM-dd HH:mm"));
        Console.WriteLine(received.UtcDateTime.ToString("yyyy-MM-dd HH:mm"));
        Console.WriteLine(received - placed);          // compared as moments
        Console.WriteLine(placed.ToOffset(TimeSpan.FromHours(9)).ToString("HH:mm zzz"));
    }
}

Output:

2026-09-24 14:00 +02:00
2026-09-24 12:00
2026-09-24 12:30
00:30:00
21:00 +09:00

Use DateTimeOffset (or UTC DateTime values) for timestamps: when an order was placed, when a message was sent. Databases and JSON serializers handle it well. For converting between named time zones with daylight saving rules, use TimeZoneInfo.ConvertTime; the zone IDs differ by operating system on older .NET versions ("Europe/Paris" on Linux, "Romance Standard Time" on Windows), and .NET 6 and later accept both.

DateOnly and TimeOnly (.NET 6 and later)

Many values are a date with no time (a birthday, a due date) or a time with no date (opening hours). .NET 6 added two types for them:

// .NET 6 and later
DateOnly birthday = new DateOnly(1990, 9, 24);
DateOnly due = DateOnly.FromDateTime(DateTime.Today).AddDays(14);
int daysLeft = due.DayNumber - DateOnly.FromDateTime(DateTime.Today).DayNumber;

TimeOnly opens = new TimeOnly(9, 0);
TimeOnly closes = new TimeOnly(17, 30);
bool isOpen = TimeOnly.FromDateTime(DateTime.Now).IsBetween(opens, closes);

They remove a class of bugs where a stray time or time zone shifts a date by one day. Older code, and code targeting .NET Framework or Unity, uses DateTime with the time left at midnight.

Common mistakes

• Discarding the result of AddDays. DateTime is immutable; assign the returned value.
• Using Hours instead of TotalHours. Components versus total duration.
• Storing DateTime.Now. Store UTC and convert for display.
• Calling ToString() without a format in logs, files or tests, where the output depends on the machine's culture.
• Parsing with DateTime.Parse on machine data. Use ParseExact and the invariant culture.
• Mixing up mm and MM in format strings (minutes and months). See DateTime format.