¿Cómo se convierte el tiempo de época en C#?

Question

¿Cómo se convierte Unix epoch time en tiempo real en C#? (Época comenzando 1/1/1970)

Answer 1

supongo que quiere decir Unix time, que se define como el número de segundos transcurridos desde la medianoche (GMT) el 1 de enero de 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); 

Answer 2

Con todo el crédito a LukeH , he reunido algunos métodos de extensión para un uso fácil:

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

Nota del comentario abajo desde CodesInChaos que lo anterior FromUnixTime devuelve un DateTime con un Kind de Utc, lo cual está bien, pero el ab ove ToUnixTime es mucho más sospechoso en que no cuenta para qué tipo de DateTime es date dado. Para permitir la date 's Kind siendo ya sea Utc o Local, utilice 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 convertirá una Local (o Unspecified) DateTime-Utc.

si no desea crear la época ejemplo DateTime cuando se pasa de DateTime de época o también se puede hacer:

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

Answer 3

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

En caso de utilizar ToUniversalTime() para el objeto DateTime.

Answer 4

En realidad quiere agregar milisegundos (milisegundos), no segundos. Agregar segundos le dará una excepción fuera de rango.

Answer 5

Aquí está mi solución:

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

Answer 6

En caso de que necesite para convertir un timeval struct (segundos, microsegundos) que contiene UNIX time a DateTime sin perder precisión, esta es la forma:

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 7

El latest version of .Net (v4.6) acaba de agregar compatibilidad integrada para las conversiones de tiempo de Unix. Eso incluye el tiempo hacia y desde Unix representado por segundos o milisegundos.

• tiempo Unix en cuestión de segundos a DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000); 

• DateTimeOffset a tiempo Unix en segundos:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds(); 

• tiempo Unix en milisegundos para DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000); 

• DateTimeOffset a tiempo Unix en milisegundos:

long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds(); 

---

Nota: Estos métodos se convierten en y desde DateTimeOffset. Para obtener una representación DateTime simplemente use el DateTimeOffset.DateTime propiedad:

DateTime dateTime = dateTimeOffset.UtcDateTime; 

Answer 8

Si no está utilizando 4.6, esto puede ayudar a Fuente:System.IdentityModel.Tokens

/// <summary> 
    /// DateTime as UTV for UnixEpoch 
    /// </summary> 
    public static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); 

    /// <summary> 
    /// Per JWT spec: 
    /// Gets the number of seconds from 1970-01-01T0:0:0Z as measured in UTC until the desired date/time. 
    /// </summary> 
    /// <param name="datetime">The DateTime to convert to seconds.</param> 
    /// <remarks>if dateTimeUtc less than UnixEpoch, return 0</remarks> 
    /// <returns>the number of seconds since Unix Epoch.</returns> 
    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; 
    }  

Answer 9

utilizo siguientes métodos de extensión para la conversión época

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

    } 

Answer 10

Si desea un mejor rendimiento, puede utilizar esta versión.

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

De referencia rápida (BenchmarkDotNet) bajo net471 consigo este número:

 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 | 

2 veces más rápido contra la versión LukeH (si el mater rendimiento)

Esto es similar cómo DateTime trabajo internamente.