wake-up-neo.com

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

Es gibt diesen Beispielcode, aber dann wird über Millisekunden-/Nanosekundenprobleme gesprochen.

Die gleiche Frage ist auf MSDN, Sekunden seit der Unix-Epoche in C #.

Das habe ich bisher:

public Double CreatedEpoch
{
  get
  {
    DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    TimeSpan span = (this.Created.ToLocalTime() - Epoch);
    return span.TotalSeconds;
  }
  set
  {
    DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    this.Created = Epoch.AddSeconds(value);
  }
}
647
Mark Ingram

Hier ist was Sie brauchen:

public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )
{
    // Unix timestamp is seconds past Epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();
    return dtDateTime;
}

Oder für Java (was anders ist, weil der Zeitstempel in Millisekunden und nicht in Sekunden angegeben wird):

public static DateTime JavaTimeStampToDateTime( double javaTimeStamp )
{
    // Java timestamp is milliseconds past Epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddMilliseconds( javaTimeStamp ).ToLocalTime();
    return dtDateTime;
}
885
ScottCher

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;
310
i3arnon

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;
}
209
Dmitry Fedorkov

"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;
44
gl051

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;
}
20
Felix Keil

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

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);
}
10
Chris Thoman

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()
7
Fred

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;
5
n8CodeGuru
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.

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

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

2
mesut

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.

2
Luk

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);
}
1
i3arnon
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.

0
madan

Ab .net 4.6 können Sie Folgendes tun:

var dateTime = DateTimeOffset.FromUnixTimeSeconds(unixDateTime).DateTime;
0
Yang Zhang