Wie kann ich einen Unix-Zeitstempel Datetime konvertieren und umgekehrt?

Question

Es ist dieses Beispiel-Code, aber dann geht es über Millisekunde / Nanosekunde Probleme zu sprechen.

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

Dies ist, was ich bisher habe:

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

Answer 1

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 (die anders ist, da der Zeitstempel 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;
}

Answer 2

Die neueste Version von .NET (v4.6) hat für Unix Zeit Konvertierungen integrierte Unterstützung hinzugefügt. Dazu gehört sowohl zu als auch von Unix Zeit entweder von Sekunden oder Millisekunden angegeben.

• Unix Zeit in Sekunden, um UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset auf Unix Zeit in Sekunden:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Unix-Zeit in Millisekunden zu UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset auf Unix-Zeit in Millisekunden:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

---

Hinweis: Diese Methoden konvertieren zu und von einer UTC DateTimeOffset. Um eine DateTime Darstellung einfach die DateTimeOffset.UtcDateTime oder DateTimeOffset.LocalDateTime Eigenschaften verwenden:

DateTime dateTime = dateTimeOffset.UtcDateTime;

Answer 3

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

Answer 4

  

UTC nicht mit einem Wechsel der Jahreszeit ändern, aber Ortszeit oder Bürger   Zeit ändern kann, wenn eine Zeitzone Zuständigkeit Sommerzeit beobachtet   Zeit (Sommerzeit). Zum Beispiel ist UTC 5 Stunden vor (das heißt,   später am Tag als) Ortszeit an der Ostküste des Vereinigten   Staaten im Winter, aber 4 Stunden vor, während der Sommerzeit ist   beobachtet dort.

Das ist also mein Code:

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

Answer 5

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

.NET (v4.6) Methoden (zum Beispiel FromUnixTimeMilliseconds ) hat diese Präzision nicht liefern.

AddSeconds und AddMilliseconds auch die Mikrosekunden im Doppel abgeschnitten.

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

Answer 6

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

Answer 7

Um ScottCher Antwort zu ergänzen, ich mich vor kurzem in das lästige Szenario gefunden beide Sekunden und Millisekunden mit UNIX Zeit willkürlich in einem Eingangsdatensatz zusammengemischt. Der folgende Code scheint dies 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);
}

Answer 8

Unix Zeitumstellung ist neu in .NET Framework 4.6.

Sie können nun leichter Datums- und Zeitwerte zu oder von .NET Framework-Typen und Unix-Zeit konvertieren. Dies kann erforderlich sein, wenn beispielsweise Zeitwert zwischen einem JavaScript-Client und .NET Server konvertieren. Die folgenden APIs haben zu der Datetime Struktur hinzugefügt:

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

Answer 9

fand ich die richtige Antwort nur durch die Umstellung auf 1.1.1970 Vergleich w / o der lokalen 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;

Answer 10

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

Natürlich kann man machen unixEpoch ein globale statische, so dass es nur einmal in Ihrem Projekt angezeigt werden muss, und man kann AddSeconds verwenden, wenn die UNIX-Zeit in Sekunden.

Um den anderen Weg zu gehen:

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

Kürzen zu Int64 und / oder TotalSeconds verwenden je nach Bedarf.

Answer 11

Eine Unix-Zecke ist 1 Sekunde (wenn ich mich recht erinnere), und eine .NET-Zecke ist 100 ns.

Wenn Sie Probleme mit ns habe zu begegnen, möchten Sie vielleicht mit AddTick (10000000 * -Wert) versuchen.

Answer 12

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

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

// [2017.11.11 10.43.11 +00: 00]

Answer 13

Von .net 4.6, Sie können dies tun:

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

Answer 14

Ich brauchte ein timeval struct zu konvertieren (Sekunden, Mikrosekunden) UNIX time enthalten, ohne DateTime Präzision zu verlieren und haben keine Antwort hier also dachte ich, finde ich vielleicht nur 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);
}

Answer 15

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 Unix Time.Unix Time To Datetime aufrufen (Doppeldatetime))

Answer 16

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