¿Cómo convertir epoch time en C#?

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

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

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

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

La última versión de de.Net (v4.6) acaba de agregar soporte integrado para conversiones de tiempo Unix. Esto incluye el tiempo desde y hacia Unix representado por segundos o milisegundos.

• Tiempo Unix en segundos hasta DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset a tiempo Unix en segundos:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Tiempo Unix en milisegundos a DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset a tiempo Unix en milisegundos:

long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds();

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

DateTime dateTime = dateTimeOffset.UtcDateTime;

Realmente desea agregar milisegundos(milisegundos), no segundos. Agregar segundos le dará una excepción fuera de rango.

// 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.

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

    }

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

Del punto de referencia rápido (BenchmarkDotNet) bajo net471 obtengo 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 rendimiento importa)

Esta es la forma similar en que DateTime funciona internamente.

En caso de que necesite convertir una estructura timeval (segundos, microsegundos) que contenga 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);
}

Si no está utilizando 4.6, esto puede ayudar Fuente: Sistema.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;
    }    

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