Question Comment puis-je convertir un horodatage Unix en DateTime et vice versa?


Il y a cet exemple de code, mais il commence à parler de problèmes en milliseconde / nanoseconde.

La même question est sur MSDN, Secondes depuis l'époque Unix en C #.

C'est ce que j'ai jusqu'ici:

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

586
2017-10-30 10:30


origine


Réponses:


Voici ce dont vous avez besoin:

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

Ou, pour Java (qui est différent parce que l'horodatage est en millisecondes, pas en secondes):

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

816
2017-10-30 14:42



le dernière version de .NET (v4.6) a ajouté un support intégré pour les conversions de temps Unix. Cela inclut à la fois vers et à partir de l'heure Unix représentée par secondes ou millisecondes.

  • Temps d'unix en secondes à UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);
  • DateTimeOffset pour unix en secondes:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();
  • Temps d'unix en millisecondes à UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);
  • DateTimeOffset au temps Unix en millisecondes:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Remarque: Ces méthodes convertissent vers et à partir d'un UTC DateTimeOffset. Pour obtenir un DateTime représentation simplement utiliser le DateTimeOffset.UtcDateTime ou DateTimeOffset.LocalDateTime Propriétés:

DateTime dateTime = dateTimeOffset.UtcDateTime;

259
2017-10-06 22:17



Horodatage DateTime vers UNIX:

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

205
2017-09-29 11:12



«L'heure UTC ne change pas avec un changement de saisons, mais l'heure locale ou civile peut changer si un fuseau horaire observe l'heure d'été (heure d'été) Par exemple, UTC est en avance de 5 heures (c'est-à-dire plus tard dans la journée) que) l'heure locale sur la côte est des États-Unis pendant l'hiver, mais 4 heures d'avance tandis que l'heure d'été y est observée. "

Donc c'est mon code:

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

44
2018-04-13 19:55



Attention, si vous avez besoin d'une précision supérieure à quelques millisecondes!

Méthodes .NET (v4.6) (par ex. FromUnixTimeMilliseconds) ne fournissent pas cette précision.

AddSeconds et AddMilliseconds également coupé les microsecondes dans le double.

Ces versions ont une haute précision:

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

18
2017-07-23 08:57



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

12
2018-04-28 01:22



Pour compléter la réponse de ScottCher, je me suis récemment retrouvé dans le scénario ennuyeux d'avoir à la fois des secondes et des millisecondes d'horodatages UNIX arbitrairement mélangés dans un ensemble de données d'entrée. Le code suivant semble bien gérer ceci:

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
2017-10-07 16:14



La conversion d'heure Unix est nouvelle dans .NET Framework 4.6.

Vous pouvez désormais convertir plus facilement les valeurs de date et d'heure vers ou à partir des types .NET Framework et de l'heure Unix. Cela peut être nécessaire, par exemple, lors de la conversion de valeurs de temps entre un client JavaScript et un serveur .NET. Les API suivantes ont été ajoutées à Structure DateTimeOffset:

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

5
2017-07-23 13:09