Wie kann ich einen Unix-Zeitstempel in DateTime konvertieren und umgekehrt?

Die neueste Version von .NET (v4.6) hat die integrierte Unterstützung für Unix-Zeitumstellungen hinzugefügt. Dies umfasst sowohl die Unix- als auch die Unix-Zeit in Sekunden oder Millisekunden.

• Unix-Zeit in Sekunden zu UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset zur Unix-Zeit in Sekunden:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Unix-Zeit in Millisekunden nach UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset zur Unix-Zeit in Millisekunden:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Hinweis: Diese Methoden konvertieren in und aus einer UTC-Variable DateTimeOffset. Um eine DateTime-Darstellung zu erhalten, verwenden Sie einfach die Eigenschaften DateTimeOffset.UtcDateTime oder DateTimeOffset.LocalDateTime:

DateTime dateTime = dateTimeOffset.UtcDateTime;

DateTime zu UNIX-Zeitstempel:

public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
    return (TimeZoneInfo.ConvertTimeToUtc(dateTime) - 
           new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).TotalSeconds;
}

"UTC ändert sich nicht mit einem Wechsel der Jahreszeiten, aber die Ortszeit oder die zivile Zeit kann sich ändern, wenn ein Zeitzonenstaat Sommerzeit (Sommerzeit) einhält. UTC ist beispielsweise 5 Stunden vor (dh später am Tag) als) Ortszeit an der Ostküste der Vereinigten Staaten im Winter, aber 4 Stunden voraus, während die Sommerzeit dort beobachtet wird. "

Das ist also mein Code:

TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;

Seien Sie vorsichtig, wenn Sie eine höhere Genauigkeit als Millisekunden benötigen!

.NET-Methoden (v4.6) (z. B. FromUnixTimeMilliseconds ) bieten diese Genauigkeit nicht.

AddSeconds und AddMilliseconds schneiden auch die Mikrosekunden im Doppel ab.

Diese Versionen haben eine hohe Präzision:

Unix -> DateTime

public static DateTime UnixTimestampToDateTime(double unixTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (long) (unixTime * TimeSpan.TicksPerSecond);
    return new DateTime(unixStart.Ticks + unixTimeStampInTicks, System.DateTimeKind.Utc);
}

DateTime -> Unix

public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (dateTime.ToUniversalTime() - unixStart).Ticks;
    return (double) unixTimeStampInTicks / TimeSpan.TicksPerSecond;
}

Siehe IdentityModel.EpochTimeExtensions

public static class EpochTimeExtensions
{
    /// <summary>
    /// Converts the given date value to Epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTime dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given date value to Epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTimeOffset dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given Epoch time to a <see cref="DateTime"/> with <see cref="DateTimeKind.Utc"/> kind.
    /// </summary>
    public static DateTime ToDateTimeFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddTicks(timeInTicks);
    }

    /// <summary>
    /// Converts the given Epoch time to a UTC <see cref="DateTimeOffset"/>.
    /// </summary>
    public static DateTimeOffset ToDateTimeOffsetFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddTicks(timeInTicks);
    }
}

Als Ergänzung zu ScottChers Antwort befand ich mich kürzlich in dem nervigen Szenario, dass UNIX-Zeitstempel für Sekunden und Millisekunden willkürlich in einem Eingabedatensatz gemischt werden. Der folgende Code scheint dies gut zu handhaben:

static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
static readonly double MaxUnixSeconds = (DateTime.MaxValue - UnixEpoch).TotalSeconds;

public static DateTime UnixTimeStampToDateTime(double unixTimeStamp)
{
   return unixTimeStamp > MaxUnixSeconds
      ? UnixEpoch.AddMilliseconds(unixTimeStamp)
      : UnixEpoch.AddSeconds(unixTimeStamp);
}

Die Unix-Zeitkonvertierung ist neu in .NET Framework 4.6.

Sie können Datums- und Uhrzeitwerte jetzt einfacher in oder aus .NET Framework-Typen und Unix-Zeiten konvertieren. Dies kann beispielsweise erforderlich sein, wenn Zeitwerte zwischen einem JavaScript-Client und einem .NET-Server konvertiert werden. Die folgenden APIs wurden der DateTimeOffset-Struktur hinzugefügt:

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()

Ich habe die richtige Antwort gefunden, indem ich die Umrechnung auf 1/1/1970 ohne die lokale Zeiteinstellung vergleicht.

DateTime date = new DateTime(2011, 4, 1, 12, 0, 0, 0);
DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);
TimeSpan span = (date - Epoch);
double unixTime =span.TotalSeconds;

DateTime unixEpoch = DateTime.ParseExact("1970-01-01", "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
DateTime convertedTime = unixEpoch.AddMilliseconds(unixTimeInMillisconds);

Natürlich kann man unixEpoch zu einer globalen Statik machen, sodass es nur einmal in Ihrem Projekt erscheinen muss, und Sie können AddSeconds verwenden, wenn die UNIX-Zeit in Sekunden ist.

Um den anderen Weg zu gehen:

double unixTimeInMilliseconds = timeToConvert.Subtract(unixEpoch).TotalMilliseconds;

Auf Int64 abschneiden und/oder TotalSeconds nach Bedarf verwenden.

var dt = DateTime.Now; 
var unixTime = ((DateTimeOffset)dt).ToUnixTimeSeconds();

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

// [11.11.2017 10:43:11 +00: 00]

Ein Unix-Tick ist 1 Sekunde (wenn ich mich recht gut erinnere) und ein .NET-Tick ist 100 Nanosekunden. 

Wenn Sie Probleme mit Nanosekunden hatten, sollten Sie AddTick (Wert 10000000 *) verwenden.

Ich musste eine timeval -Struktur (Sekunden, Mikrosekunden) mit UNIX time in DateTime konvertieren, ohne die Genauigkeit zu verlieren, und habe hier keine Antwort gefunden. Ich dachte, ich könnte meine hinzufügen:

DateTime _epochTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
private DateTime UnixTimeToDateTime(Timeval unixTime)
{
    return _epochTime.AddTicks(
        unixTime.Seconds * TimeSpan.TicksPerSecond +
        unixTime.Microseconds * TimeSpan.TicksPerMillisecond/1000);
}

public static class UnixTime
    {
        private static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);

        public static DateTime UnixTimeToDateTime(double unixTimeStamp)
        {
            return Epoch.AddSeconds(unixTimeStamp).ToUniversalTime();
        }
    }

sie können UnixTime aufrufen.

Ab .net 4.6 können Sie Folgendes tun:

var dateTime = DateTimeOffset.FromUnixTimeSeconds(unixDateTime).DateTime;