Comment convertissez-vous le temps d’epoch en C #?

Comment est-ce que vous convertissez le temps d’epix d’ Unix en temps réel en C #? (Époque débutant le 1/1/1970)

Je suppose que vous parlez de l’ heure Unix , qui est définie comme le nombre de secondes écastings depuis minuit (UTC) le 1er janvier 1970.

public static DateTime FromUnixTime(long unixTime) { return epoch.AddSeconds(unixTime); } private static readonly DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); 

Avec tout le crédit accordé à LukeH, j’ai mis au sharepoints méthodes d’extension faciles à utiliser:

 public static DateTime FromUnixTime(this long unixTime) { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return epoch.AddSeconds(unixTime); } public static long ToUnixTime(this DateTime date) { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return Convert.ToInt64((date - epoch).TotalSeconds); } 

Notez le commentaire ci-dessous de CodesInChaos que FromUnixTime ci-dessus renvoie un DateTime avec un Kind d’ Utc , ce qui est bien, mais le ToUnixTime ci-dessus est beaucoup plus suspect dans ce qui ne tient pas compte du type de DateTime . Pour autoriser le type date soit Utc soit Local , utilisez ToUniversalTime :

 public static long ToUnixTime(this DateTime date) { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return Convert.ToInt64((date.ToUniversalTime() - epoch).TotalSeconds); } 

ToUniversalTime convertira un DateTime Local (ou Unspecified ) en Utc .

Si vous ne voulez pas créer l’occurrence de DateTime d’époque lorsque vous passez de DateTime à epoch, vous pouvez également:

 public static long ToUnixTime(this DateTime date) { return (date.ToUniversalTime().Ticks - 621355968000000000) / 10000000; } 

La dernière version de .Net (v4.6) vient d’append la prise en charge intégrée des conversions de temps Unix. Cela inclut à la fois l’heure et la durée sous Unix représentée par les secondes ou les millisecondes.

  • Temps Unix en secondes à DateTimeOffset :
 DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000); 
  • DateTimeOffset à Unix temps en secondes:
 long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds(); 
  • Temps Unix en millisecondes pour DateTimeOffset :
 DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000); 
  • DateTimeOffset à l’heure Unix en millisecondes:
 long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds(); 

Remarque: Ces méthodes convertissent vers et depuis DateTimeOffset . Pour obtenir une représentation DateTime utilisez simplement la propriété DateTimeOffset.DateTime :

 DateTime dateTime = dateTimeOffset.UtcDateTime; 

Vous voulez réellement append des millisecondes (millisecondes), pas des secondes. L’ajout de secondes vous donnera une exception hors de scope.

 // convert datetime to unix epoch seconds public static long ToUnixTime(DateTime date) { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return Convert.ToInt64((date.ToUniversalTime() - epoch).TotalSeconds); } 

Devrait utiliser ToUniversalTime () pour l’object DateTime.

J’utilise les méthodes d’extension suivantes pour la conversion d’époque

 public static int GetEpochSeconds(this DateTime date) { TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); return (int)t.TotalSeconds; } public static DateTime FromEpochSeconds(this DateTime date, long EpochSeconds) { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return epoch.AddSeconds(EpochSeconds); } 

Si vous voulez de meilleures performances, vous pouvez utiliser cette version.

 public const long UnixEpochTicks = 621355968000000000; public const long TicksPerMillisecond = 10000; public const long TicksPerSecond = TicksPerMillisecond * 1000; //[MethodImpl(MethodImplOptions.AggressiveInlining)] public static DateTime FromUnixTimestamp(this long unixTime) { return new DateTime(UnixEpochTicks + unixTime * TicksPerSecond); } 

À partir de benchmark rapide (BenchmarkDotNet) sous net471, j’obtiens ce numéro:

  Method | Mean | Error | StdDev | Scaled | -------------- |---------:|----------:|----------:|-------:| StackOverflow | 5.897 ns | 0.0897 ns | 0.0795 ns | 1.00 | MyCustom | 3.176 ns | 0.0573 ns | 0.0536 ns | 0.54 | 

2x plus rapide contre la version de LukeH (si la performance est importante)

Ceci est similaire à la façon dont DateTime fonctionne en interne.

Si vous devez convertir une structure temporelle (secondes, microsecondes) contenant l’ UNIX time en DateTime sans perdre en précision, voici comment:

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

Si vous n’utilisez pas 4.6, cela peut aider Source: System.IdentityModel.Tokens

  ///  /// DateTime as UTV for UnixEpoch ///  public static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); ///  /// Per JWT spec: /// Gets the number of seconds from 1970-01-01T0:0:0Z as measured in UTC until the desired date/time. ///  /// The DateTime to convert to seconds. /// if dateTimeUtc less than UnixEpoch, return 0 /// the number of seconds since Unix Epoch. public static long GetIntDate(DateTime datetime) { DateTime dateTimeUtc = datetime; if (datetime.Kind != DateTimeKind.Utc) { dateTimeUtc = datetime.ToUniversalTime(); } if (dateTimeUtc.ToUniversalTime() <= UnixEpoch) { return 0; } return (long)(dateTimeUtc - UnixEpoch).TotalSeconds; } 

Voici ma solution:

 public long GetTime() { DateTime dtCurTime = DateTime.Now.ToUniversalTime(); DateTime dtEpochStartTime = Convert.ToDateTime("1/1/1970 0:00:00 AM"); TimeSpan ts = dtCurTime.Subtract(dtEpochStartTime); double epochtime; epochtime = ((((((ts.Days * 24) + ts.Hours) * 60) + ts.Minutes) * 60) + ts.Seconds); return Convert.ToInt64(epochtime); }