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

System.DateTime stellt ein Datum und eine Uhrzeit dar, vom Jahr 1 bis zum Jahr 9999, mit einer Genauigkeit von 100 Nanosekunden (ein „Tick“). System.TimeSpan stellt eine Dauer dar: die Differenz zwischen zwei DateTime-Werten. Beide sind unveränderliche Werttypen (Structs), jede Operation gibt also einen neuen Wert zurück.

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

Ausgabe:

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

Jedes Beispiel auf dieser Seite gibt Datumswerte mit einem expliziten Formatstring aus. Das Standard-ToString() folgt der aktuellen Kultur (9/24/2026 2:30:00 PM in den USA, 24.09.2026 14:30:00 in Deutschland), seine Ausgabe hängt also vom Rechner ab. Die Formatcodes findest du unter DateTime-Format.

Ein ungültiges Datum wirft: new DateTime(2026, 2, 30) löst eine ArgumentOutOfRangeException aus, ebenso Monat 13 oder Stunde 24.

Now, UtcNow und Today

Drei statische Properties lesen die Uhr:

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

Beispielausgabe:

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

In diesem Beispiel liegt die lokale Zeitzone zwei Stunden vor UTC, die ersten beiden Zeilen unterscheiden sich also um zwei Stunden; auf einem auf UTC eingestellten Rechner stimmen sie überein. Die Property Kind hält fest, ob ein Wert Local, Utc oder Unspecified ist (der Standard für selbst erzeugte Datumswerte). Nimm DateTime.UtcNow für alles, was du speicherst, protokollierst, vergleichst oder an ein anderes System schickst: Es springt nicht, wenn die Sommerzeit beginnt oder endet, und bedeutet auf jedem Server denselben Zeitpunkt. Wandle nur in lokale Zeit um, wenn du einem Menschen einen Wert anzeigst.

Um zu messen, wie lange Code braucht, nimm System.Diagnostics.Stopwatch statt zwei DateTime.Now-Werte zu subtrahieren; er hat eine viel feinere Auflösung und ist von Uhrkorrekturen nicht betroffen.

Zeit addieren und subtrahieren

AddDays, AddHours, AddMinutes, AddSeconds, AddMonths und AddYears geben einen neuen DateTime zurück. Übergib eine negative Zahl, um zurückzugehen. Weil DateTime unveränderlich ist, muss das Ergebnis zugewiesen werden:

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

Ausgabe:

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

AddMonths begrenzt auf den letzten Tag des Monats, wenn der Tag nicht existiert: 31. Januar plus ein Monat ist der 28. Februar (oder 29. in einem Schaltjahr), nicht der 3. März. Zweimal einen Monat zu addieren und einmal zwei Monate zu addieren kann daher verschiedene Datumswerte ergeben.

Datumswerte subtrahieren: TimeSpan

Wird ein DateTime von einem anderen subtrahiert, ergibt sich ein 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}");
    }
}

Ausgabe:

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

Das ist der Teil der API, den Leute am häufigsten falsch verwenden. Days, Hours, Minutes und Seconds sind die Komponenten der Spanne (3 Tage, 20 Stunden, 30 Minuten). TotalDays, TotalHours und TotalMinutes sind die gesamte Dauer in einer Einheit, als double. „Wie viele Stunden ist der Gast geblieben?“ ist TotalHours (92.5), nicht Hours (20).

Die letzte Zeile zeigt einen verwandten Punkt: 3.85 Tage sind vergangen, aber der Gast ist 4 Nächte geblieben. Der Vergleich der .Date-Anteile zählt Kalendertage, und das ist meist, was Abrechnungen und Anzeigen wie „noch n Tage“ brauchen.

TimeSpan-Werte erzeugen und formatieren

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

Ausgabe:

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

TimeSpan unterstützt +, -, Vergleiche, Duration() (Absolutwert) und Negate(). Benutzerdefinierte Formate wie @"hh\:mm" brauchen einen Backslash vor wörtlichen Zeichen, und hh zeigt dort nur die Stundenkomponente (0 bis 23). Für Dauern über einen Tag baue den Text daher aus TotalHours, wie in der vorletzten Zeile.

Datumswerte vergleichen

DateTime unterstützt ==, !=, <, >, <= und >= sowie CompareTo und DateTime.Compare. Um nur das Datum zu vergleichen und die Uhrzeit zu ignorieren, vergleiche die .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"));
    }
}

Ausgabe:

True
True
1
True
2026-09-01

Für „liegt dieser Zeitstempel am 30. September?“ vergleiche wie oben mit < gegen den Beginn des nächsten Tages. check <= end würde alles nach Mitternacht am letzten Tag ausschließen, weil end 2026-09-30 00:00:00 ist.

Vergleiche schauen nur auf die Ticks, nicht auf Kind: Ein Local-Wert und ein Utc-Wert, die gleich ausgegeben werden, gelten als gleich, obwohl sie verschiedene Zeitpunkte sind. Ein weiterer Grund, gespeicherte Zeiten in UTC zu halten.

Wochentag und Wochenbeginn

DayOfWeek ist ein Enum von Sunday (0) bis Saturday (6). Mit Arithmetik darauf findest du Wochentage und Wochengrenzen:

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

Ausgabe:

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

Die Tagesnamen, die DayOfWeek.ToString() ausgibt, sind immer englisch. Für einen lokalisierten Namen formatiere das Datum mit "dddd" und einer Kultur.

Datumswerte aus Strings parsen

Wenn du das Format der Eingabe kennst, nimm ParseExact oder TryParseExact mit CultureInfo.InvariantCulture. Der Formatstring verwendet dieselben Codes wie beim Formatieren:

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

Ausgabe:

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) ohne Format versucht, mit der aktuellen Kultur zu raten. "03/04/2026" ist auf einem US-Rechner der 4. März und auf einem britischen der 3. April, und ein Datum, das auf deinem Laptop geparst wird, kann auf einem Server eine FormatException werfen. Behalte Parse für Eingaben, die ein lokaler Benutzer tippt; nimm ParseExact mit der invarianten Kultur für Dateien, APIs und Datenbanken. ParseExact wirft FormatException, wenn der Text nicht passt; TryParseExact gibt stattdessen false zurück.

Ein Alter berechnen

Geburtsdaten zu subtrahieren und durch 365 zu teilen ist rund um Geburtstage und Schaltjahre falsch. Vergleiche die Jahre und korrigiere, wenn der diesjährige Geburtstag noch nicht war:

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

Ausgabe:

36
35
18
70 days to go

DateTimeOffset

Ein DateTime hält über das vage Flag Kind hinaus nicht fest, in welcher Zeitzone er liegt. DateTimeOffset speichert den Wert zusammen mit seinem Versatz zu UTC und identifiziert so immer einen exakten Zeitpunkt:

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

Ausgabe:

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

Nimm DateTimeOffset (oder DateTime-Werte in UTC) für Zeitstempel: wann eine Bestellung aufgegeben, wann eine Nachricht gesendet wurde. Datenbanken und JSON-Serializer kommen gut damit zurecht. Für die Umrechnung zwischen benannten Zeitzonen mit Sommerzeitregeln nimm TimeZoneInfo.ConvertTime; die Zonen-IDs unterscheiden sich in älteren .NET-Versionen je nach Betriebssystem ("Europe/Paris" unter Linux, "Romance Standard Time" unter Windows), und ab .NET 6 werden beide akzeptiert.

DateOnly und TimeOnly (ab .NET 6)

Viele Werte sind ein Datum ohne Uhrzeit (ein Geburtstag, ein Fälligkeitsdatum) oder eine Uhrzeit ohne Datum (Öffnungszeiten). .NET 6 hat dafür zwei Typen hinzugefügt:

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

Sie beseitigen eine Klasse von Bugs, bei denen eine versehentliche Uhrzeit oder Zeitzone ein Datum um einen Tag verschiebt. Älterer Code und Code für .NET Framework oder Unity verwendet DateTime mit der Uhrzeit auf Mitternacht.

Häufige Fehler

• Das Ergebnis von AddDays verwerfen. DateTime ist unveränderlich; weise den zurückgegebenen Wert zu.
• Hours statt TotalHours verwenden. Komponenten gegenüber Gesamtdauer.
• DateTime.Now speichern. Speichere UTC und wandle für die Anzeige um.
• ToString() ohne Format aufrufen in Logs, Dateien oder Tests, wo die Ausgabe von der Kultur des Rechners abhängt.
• Maschinendaten mit DateTime.Parse parsen. Nimm ParseExact und die invariante Kultur.
• mm und MM verwechseln in Formatstrings (Minuten und Monate). Siehe DateTime-Format.