Cum pot converti un Unix timestamp să DateTime și vice-versa?

Există acest exemplu de cod, dar apoi începe să vorbească despre milisecundă / nanosecundă probleme.

Aceeași întrebare este pe MSDN, Secunde de la epoca Unix în C#.

Aceasta este ceea ce am'am primit până acum:

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);
  }
}
Peter Mortensen
Întrebarea editată 15 ianuarie 2018 в 8:36
Programare
datetime c# unix data-conversion epoch
30 octombrie 2008 в 10:30
8 vizualizări
Comentarii la întrebare (1)
Soluția

Aici's de ce ai nevoie:

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

Sau, pentru Java (care este diferit, deoarece timestamp este în milisecunde, nu secunde):

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;
}
Comentarii (12)

A mai recentă versiune de .NET (v4.6) și-a adăugat built-in de sprijin pentru Unix conversii în timp. Care include atât la și de la Unix, reprezentate de secunde sau milisecunde.

  • Unix timp, în secunde, UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);
  • `DateTimeOffset să Unix timpul în secunde:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();
  • Unix timp în milisecunde pentru a UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);
  • `DateTimeOffset să Unix timp în milisecunde:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Notă: Aceste metode de a converti la și de la un UTC DateTimeOffset. Pentru a obține un "DateTime" reprezentare pur și simplu utilizați DateTimeOffset.UtcDateTime " sau " DateTimeOffset.LocalDateTime properties:

DateTime dateTime = dateTimeOffset.UtcDateTime;
samlh
Răspuns editat 21 iunie 2018 в 2:16
Comentarii (4)

DateTime pentru 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;
}
Comentarii (0)

De Wikipedia:

UTC nu se schimba cu schimbarea anotimpurilor, dar ora locală sau civile în timp, se poate schimba dacă un fusul orar jurisdicția observă ora de vară (ora de vară). De exemplu, ora locală, pe coasta de est a Statelor Unite este de cinci ore în urmă UTC în timpul iernii, dar și patru de ore în urmă în timp ce daylight saving se observă acolo.

Deci, acesta este codul meu:

TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;
Pang
Răspuns editat 31 iulie 2019 в 1:20
Comentarii (1)

Fii atent, dacă aveți nevoie de o precizie mai mare decât milisecunde!

.NET (v4.6) metode (de exemplu, FromUnixTimeMilliseconds) nu't oferi această precizie.

AddSeconds și AddMilliseconds de asemenea, taie microsecunde, în dublu.

Aceste versiuni au ridicat de precizie:

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;
}
Felix Keil
Răspuns editat 19 februarie 2018 в 8:50
Comentarii (4)

Vezi IdentityModel.EpochTimeExtensions

public static class EpochTimeExtensions
{
    /// 
    /// Converts the given date value to epoch time.
    /// 
    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;
    }

    /// 
    /// Converts the given date value to epoch time.
    /// 
    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;
    }

    /// 
    /// Converts the given epoch time to a  with  kind.
    /// 
    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);
    }

    /// 
    /// Converts the given epoch time to a UTC .
    /// 
    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);
    }
}
Comentarii (2)

Pentru a completa ScottCher's a răspuns, recent m-am trezit într-enervant scenariu de a avea atât de secunde și milisecunde UNIX timestamp arbitrar amestecate împreună într-un set de date de intrare. Codul de mai jos pare să se ocupe de acest bine:

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);
}
Comentarii (2)

Unix timpul de conversie este nou în .NET Framework 4.6.

Acum puteți converti cu ușurință mai multe valori de dată și timp către sau de la .NET Framework tipuri și de timp Unix. Acest lucru poate fi necesar, de exemplu, atunci când conversia valorilor de timp între un client JavaScript și .Server de NET. Următoarele Api-uri au fost adăugate la DateTimeOffset structura:

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()
Elanis
Răspuns editat 17 aprilie 2019 в 8:22
Comentarii (3)

Am găsit răspunsul corect doar prin compararea conversie a 1/1/1970 w/o locale timp de ajustare;

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;
Comentarii (0)
var dt = DateTime.Now; 
var unixTime = ((DateTimeOffset)dt).ToUnixTimeSeconds();

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

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

Desigur, se poate face unixEpoch un globale statice, astfel încât trebuie să apară o singură dată în proiect, și se poate folosi AddSeconds dacă timpul UNIX este în secunde.

Pentru a merge în altă parte:

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

Truncate la Int64 și/sau de a folosi TotalSeconds după cum este necesar.

Comentarii (0)

Un Unix capusa este de 1 secundă (dacă îmi amintesc bine), si un .NET capusa este 100 nanosecunde.

Daca'am fost întâmpină probleme cu nanosecunde, ați putea dori să încercați să utilizați AddTick(10000000 * valoare).

Comentarii (1)

De la .net de 4,6, puteți face acest lucru:

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

Am nevoie pentru a converti o struct timeval (secunde, microsecunde) cu conținut de timp UNIX a "DateTime", fără a pierde din precizie și am't a găsit un răspuns aici, așa că am crezut că am putea adăuga mea:

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);
}
Elanis
Răspuns editat 17 aprilie 2019 в 6:53
Comentarii (0)
 
System.DateTimeOffset.Now.ToUnixTimeSeconds()
Comentarii (0)

Scrise o simplă extensie care lucrează pentru noi. Dacă cineva se uită de el...

public static class DateTimeExtensions
{
    public static DateTime FromUnixTimeStampToDateTime(this string unixTimeStamp)
    {

        return DateTimeOffset.FromUnixTimeSeconds(long.Parse(unixTimeStamp)).UtcDateTime;
    }
}
Comentarii (0)
 
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();
        }
    }

puteți apela UnixTime.UnixTimeToDateTime(dublu datetime))

madan
Răspuns editat 18 iunie 2018 в 7:43
Comentarii (0)

Pentru .NET 4.6 și mai târziu:

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);
    }
}
Comentarii (1)