C# DateTime.Ticks in Unix-Timestamp und andere Formate umrechnen

Mit den DateTime-Funktionen des .NET-Frameworks lässt sich so einiges anstellen. Der Umgang damit gestaltet sich, meiner Meinung nach, sehr angenehm. Einzige Voraussetzung: Man befindet sich in einer reinen .NET-Umgebung. Kommen andere Systeme ins Spiel, so geht die Rechnerei los. Aber woran liegt es, dass man zum Beispiel DateTime.Ticks nicht mit der PHP-Funktion mktime() vergleichen kann?

Ruft man den “Timestamp” eines DateTime-Objekts (DateTime.Ticks) ab, so bekommt man die Anzahl der Ticks seit dem 01.01.0001 00:00Uhr zurück. Ein Tick wiederum ist 100 Nanosekunden lang.
Ein Unix-Timestamp, so wie ihn mktime() zum Beispiel produziert, gibt im Gegenteil zu DateTime.Ticks die Anzahl der Sekunden seit dem 01.01.1970 zurück.
Ein direkter Vergleich ist somit nicht möglich. Wie umgerechnet werden muss, möchte ich euch heute anhand von ein paar kurzen Snippets zeigen.

Unix-Timestamp -> DateTime.Ticks

private static DateTime TimeFromUnixTimestamp(int unixTimestamp)
{
    DateTime unixYear0 = new DateTime(1970, 1, 1);
    long unixTimeStampInTicks = unixTimestamp * TimeSpan.TicksPerSecond;
    DateTime dtUnix = new DateTime(unixYear0.Ticks + unixTimeStampInTicks);
    return dtUnix;
}

Zuerst wird ein DateTime-Objekt erstellt, dass den Zeitpunkt des Beginns der Unix-Zeitrechnung angibt. Danach wird der (in Sekunden angegebene) Unix-Timestamp in Ticks umgerechnet. Zum Schluss wird ein neues DateTime-Objekt erzeugt, dass die Ticks des Unix-Epochen-Beginns, sowie des Unix-Timespans in Ticks enthält.

DateTime.Ticks -> Unix-Timestamp

public static long UnixTimestampFromDateTime(DateTime date)
{
    long unixTimestamp = date.Ticks - new DateTime(1970, 1, 1).Ticks;
    unixTimestamp /= TimeSpan.TicksPerSecond;
    return unixTimestamp;
}

Zuerst wird die Anzahl der Ticks vom Beginn der DateTime-Zeitrechnung (siehe Einleitung) bis zum Beginn der Unix-Zeitrechnung abgezogen. Danach hat man quasi schon einen Unix-Timestamp – bloß in Ticks statt in Sekunden. Eben diese werden abschließend noch von Ticks in Sekunden umgerechnet (TimeSpan.TicksPerSecond ist unser Freund) und schon ist die Umrechnung abgeschlossen.

[Java] System.currentTimeMillis() -> DateTime.Ticks

private static DateTime TimeFromJavaTimestamp(long javaTimestamp)
{
    return TimeFromUnixTimestamp((int)(javaTimestamp / 1000));
}

Der Java-Timestamp (System.currentTimeMillis()) ist fast identisch mit dem standard Unix-Timestamp. Die Zeitrechnung beginnt ebenfalls am 01.01.1970. Der Unterschied liegt lediglich darin, dass der Timestamp in Java in Millisekunden, statt in Sekunden, angegeben wird. Somit können wir uns die oben erstelle Funktion zur Umrechnung zu nutze machen und dessen Ergebnis einfach durch 1000 dividieren.

DateTime.Ticks -> [Java] System.currentTimeMillis()

public static long JavaTimestampFromDateTime(DateTime date)
{
    return (UnixTimestampFromDateTime(date) * 1000);
}

Um DateTime.Ticks in einen Java-Timestamp umzurechnen müssen wir nur einen Unix-Timestamp erstellen und mit 1000 multiplizieren. (Warum das so ist hatte ich einen Absatz weiter oben ja bereits beschrieben.)

Ich hoffe, ich konnte dem ein oder anderen Suchenden damit ein wenig weiterhelfen. Solltet ihr noch Fragen oder Verbesserungsvorschläge haben, schreibt mir einfach einen Kommentar. Ich bin gerne bereit den Artikel zu überarbeiten, wenn ihr einen besseren Vorschlag habt. (Man lernt ja nie aus.)

Viele Grüße,
Raffi