c# - minutos - human time to unix time

¿Cómo convertir tiempo de época en C#?

Question

¿Cómo convertir el tiempo de Unix en tiempo real en C #? (Época que comienza el 1/1/1970)

Answer 1

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 2

Con todo el mérito de LukeH, he reunido algunos métodos de extensión para facilitar su uso:

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

Tenga en cuenta el comentario a continuación de CodesInChaos que el FromUnixTime anterior devuelve un DateTime con un Kind de Utc , que está bien, pero el ToUnixTime anterior es mucho más sospechoso ya que no tiene en cuenta qué tipo de DateTime la date dada. Para permitir que el tipo de date sea Utc o Local , use 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á un DateTime Local (o Unspecified ) a Utc .

Si no desea crear la instancia DateTime de epoch al pasar de DateTime a epoch, también puede hacer:

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

Answer 3

En caso de que necesite convertir una estructura de tiempo (segundos, microsegundos) que contenga el UNIX time a DateTime sin perder precisión, así es como:

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 4

En realidad, desea agregar milisegundos (milisegundos), no segundos. Añadir segundos te dará una excepción fuera de rango.

Answer 5

La última versión de .Net (v4.6) acaba de agregar soporte incorporado para las conversiones de tiempo Unix. Eso incluye tanto el tiempo de Unix como el de Unix representado por segundos o milisegundos.

• Tiempo de Unix en segundos para DateTimeOffset :

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset a Unix tiempo en segundos:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Tiempo de Unix en milisegundos para DateTimeOffset :

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset a la hora de Unix en milisegundos:

long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds();

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

DateTime dateTime = dateTimeOffset.UtcDateTime;

Answer 6

Si no está utilizando 4.6, esto puede ayudar 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 7

Si quieres un mejor rendimiento puedes usar 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 un punto de referencia rápido (BenchmarkDotNet) bajo net471 obtengo este número:

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

2 share más share (si el rendimiento es mater)

Esto es similar a cómo funciona DateTime internamente.

Answer 8

Supongo que te refieres a la hora de Unix , que se define como el número de segundos desde la medianoche (UTC) del 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 9

Uso los siguientes métodos de extensión para la conversión de é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

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

Debería usar ToUniversalTime () para el objeto DateTime.