Cómo obtener la marca de tiempo unix en C#

A partir de. NET 4.6, hay DateTimeOffset.ToUnixTimeSeconds().

Este es un método de instancia, por lo que se espera que lo llame en una instancia de DateTimeOffset. También puede lanzar cualquier instancia de DateTime, aunque tenga cuidado con la zona horaria.

Para obtener la marca de tiempo actual:

DateTimeOffset.UtcNow.ToUnixTimeSeconds()

Para obtener la marca de tiempo de un DateTime:

DateTime foo = DateTime.UtcNow;
long unixTime = ((DateTimeOffset)foo).ToUnixTimeSeconds();

También puedes usar Ticks. Estoy codificando para Windows Mobile, así que no tengo el conjunto completo de métodos. TotalSeconds no está disponible para mí.

long epochTicks = new DateTime(1970, 1, 1).Ticks;
long unixTime = ((DateTime.UtcNow.Ticks - epochTicks) / TimeSpan.TicksPerSecond);

O

TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
double unixTime = unixTicks.TotalSeconds;

Esto es lo que uso:

public long UnixTimeNow()
{
    var timeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
    return (long)timeSpan.TotalSeconds;
}

Tenga en cuenta que este método devolverá la hora como Hora Universal Coordinada (UTC).

Truncar .TotalSeconds es importante ya que se define como the value of the current System.TimeSpan structure expressed in whole fractional seconds.

¿Y qué tal una extensión para DateTime? El segundo es probablemente más confuso que vale la pena hasta que existan extensiones de propiedad.

/// <summary>
/// Converts a given DateTime into a Unix timestamp
/// </summary>
/// <param name="value">Any DateTime</param>
/// <returns>The given DateTime in Unix timestamp format</returns>
public static int ToUnixTimestamp(this DateTime value)
{
    return (int)Math.Truncate((value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

/// <summary>
/// Gets a Unix timestamp representing the current moment
/// </summary>
/// <param name="ignored">Parameter ignored</param>
/// <returns>Now expressed as a Unix timestamp</returns>
public static int UnixTimestamp(this DateTime ignored)
{
    return (int)Math.Truncate((DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

Cuando resta 1970 de la hora actual, tenga en cuenta que el intervalo de tiempo más a menudo tendrá un campo de milisegundos distinto de cero. Si por alguna razón usted está interesado en los milisegundos, tenga esto en cuenta.

Esto es lo que hice para evitar este problema.

 DateTime now = UtcNow();

 // milliseconds Not included.
 DateTime nowToTheSecond = new DateTime(now.Year,now.Month,now.Day,now.Hour,now.Minute,now.Second); 

 TimeSpan span = (date - new DateTime(1970, 1, 1, 0, 0, 0, 0));

 Assert.That(span.Milliseconds, Is.EqualTo(0)); // passes.

Esto es lo que uso.

 public class TimeStamp
    {
        public Int32 UnixTimeStampUTC()
        {
            Int32 unixTimeStamp;
            DateTime currentTime = DateTime.Now;
            DateTime zuluTime = currentTime.ToUniversalTime();
            DateTime unixEpoch = new DateTime(1970, 1, 1);
            unixTimeStamp = (Int32)(zuluTime.Subtract(unixEpoch)).TotalSeconds;
            return unixTimeStamp;
        }
}

Esta solución ayudó en mi situación:

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

Usando helper en código:

double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)

He empalmado los enfoques más elegantes de este método de utilidad:

public static class Ux {
    public static decimal ToUnixTimestampSecs(this DateTime date) => ToUnixTimestampTicks(date) / (decimal) TimeSpan.TicksPerSecond;
    public static long ToUnixTimestampTicks(this DateTime date) => date.ToUniversalTime().Ticks - UnixEpochTicks;
    private static readonly long UnixEpochTicks = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
}