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

Gibt es in diesem Beispiel-code, aber dann fängt es an zu sprechen Millisekunde /Nanosekunde Probleme.

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

Dies ist, was ich habe, so weit:

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

InformationsquelleAutor der Frage Mark Ingram | 2008-10-30

c#data-conversion datetime epoch unix

812

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 ist anders, weil der timestamp ist in Millisekunden, nicht Sekunden):

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

InformationsquelleAutor der Antwort ScottCher

254

Den die Letzte version von .NET (v4.6) hat Hinzugefügt integrierte Unterstützung für die Unix-Zeit-Konvertierungen. Gehören beide zu und von der Unix-Zeit vertreten, indem Sie entweder in Sekunden oder Millisekunden.
- Unix-Zeit in Sekunden, UTC DateTimeOffset:
```
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);
```
- DateTimeOffset zu Unix-Zeit in Sekunden:
```
long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();
```
- Unix-Zeit in Millisekunden der UTC -DateTimeOffset:
```
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);
```
- DateTimeOffset zu Unix-Zeit in Millisekunden:
```
long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();
```
Hinweis: Diese Methoden zum konvertieren von UTC DateTimeOffset. Um eine DateTime Darstellung verwenden Sie einfach die DateTimeOffset.UtcDateTime oder DateTimeOffset.LocalDateTime Eigenschaften:
```
DateTime dateTime = dateTimeOffset.UtcDateTime;
```
InformationsquelleAutor der Antwort i3arnon

204

DateTime zu UNIX timestamp:

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

InformationsquelleAutor der Antwort Dmitry Fedorkov

44

"UTC ändert sich nicht mit der Saison ändern, aber die lokale Zeit oder die in der bürgerlichen Zeit ändern kann, wenn ein Zeit-zone zuständig, beobachtet daylight saving time (summer time). Zum Beispiel, UTC-5 Stunden Voraus (das ist, später am Tag als die lokale Uhrzeit), an der Ostküste der Vereinigten Staaten während des Winters, aber 4 Stunden Voraus, während der Sommerzeit ist zu beachten."

Also das ist mein code:
```
TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;
```
InformationsquelleAutor der Antwort gl051

Vorsichtig sein, wenn Sie brauchen, Präzision höher als Millisekunden!

.NET (v4.6) Methoden (z.B. FromUnixTimeMilliseconds) nicht diese Präzision.

AddSeconds und AddMilliseconds auch schneiden Sie die Mikrosekunden in die Doppel.

Diese Versionen besitzen 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;
}

InformationsquelleAutor der Antwort Felix Keil

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

InformationsquelleAutor der Antwort orad

Ergänzen ScottCher Antwort, vor kurzem fand ich mich der lästigen Szenario, dass sowohl die Sekunden und die Millisekunden UNIX-Zeitstempel beliebig gemischt zusammen in ein input-Daten gesetzt. Der folgende code scheint das zu handhaben, gut:

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

InformationsquelleAutor der Antwort Chris Thoman

5

Unix-Zeit-Konvertierung ist neu .NET Framework 4.6.

Können Sie jetzt leicht konvertieren von Datum-und Zeit-Werte, um oder aus .NET Framework-Typen und Unix-Zeit. Dies kann zum Beispiel notwendig sein, wenn die Umwandlung von Zeit-Werten zwischen einen JavaScript-client und .NET-server. Die folgenden APIs wurden Hinzugefügt, um die DateTimeOffset-Struktur:
```
static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()
```
InformationsquelleAutor der Antwort Fred

Fand ich die richtige Antwort nur durch den Vergleich der Konvertierung zu 1/1/1970 w/o die lokale Zeiteinstellung;

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;

InformationsquelleAutor der Antwort 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 eine Globale statische, so dass es muss nur einmal in Ihrem Projekt, und man kann AddSeconds wenn die UNIX-Zeit in Sekunden.

In die andere Richtung gehen:

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

Abschneiden zu Int64 und/oder verwenden TotalSeconds als nötig.

InformationsquelleAutor der Antwort Hot Licks

2

Einem Unix-tick ist 1 Sekunde (wenn ich mich gut erinnern), und ein .NET tick 100 Nanosekunden.

Wenn du schon auf Probleme mit Nanosekunden, möchten Sie vielleicht zu versuchen, mit AddTick(10000000 * - Wert).

InformationsquelleAutor der Antwort Luk

Ich brauchte, um zu konvertieren eine struct timeval (Sekunden, Mikrosekunden) mit UNIX time zu DateTime ohne an Präzision zu verlieren und nicht gefunden haben, hier eine Antwort, so dachte ich, ich könnte nur hinzufügen, mine:

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

InformationsquelleAutor der Antwort 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();
        }
    }

können Sie anrufen UnixTime.UnixTimeToDateTime(double, datetime))

InformationsquelleAutor der Antwort madan

-1

Für .NET 4.6 und höher:

public static class UnixDateTime
{
    public static DateTimeOffset FromUnixTimeSeconds(long seconds)
    {
        if (seconds < -62135596800L || seconds > 253402300799L)
            throw new ArgumentOutOfRangeException("seconds", seconds, "");

        return new DateTimeOffset(seconds * 10000000L + 621355968000000000L, TimeSpan.Zero);
    }

    public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
    {
        if (milliseconds < -62135596800000L || milliseconds > 253402300799999L)
            throw new ArgumentOutOfRangeException("milliseconds", milliseconds, "");

        return new DateTimeOffset(milliseconds * 10000L + 621355968000000000L, TimeSpan.Zero);
    }

    public static long ToUnixTimeSeconds(this DateTimeOffset utcDateTime)
    {
        return utcDateTime.Ticks / 10000000L - 62135596800L;
    }

    public static long ToUnixTimeMilliseconds(this DateTimeOffset utcDateTime)
    {
        return utcDateTime.Ticks / 10000L - 62135596800000L;
    }

    [Test]
    public void UnixSeconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInSeconds = utcNowOffset.ToUnixTimeSeconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeSeconds(unixTimestampInSeconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
    }

    [Test]
    public void UnixMilliseconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInMilliseconds = utcNowOffset.ToUnixTimeMilliseconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeMilliseconds(unixTimestampInMilliseconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
        Assert.AreEqual(utcNowOffset.Millisecond, utcNowOffsetTest.Millisecond);
    }
}

InformationsquelleAutor der Antwort superlogical

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.