Jak uzyskać znacznik czasu unix w C#

Od. NET 4.6 istnieje DateTimeOffset.ToUnixTimeSeconds().

Jest to metoda instancji, więc należy ją wywołać na instancji DateTimeOffset. Możesz również rzucić dowolną instancję DateTime, chociaż uważaj na strefę czasową.

Aby pobrać bieżący znacznik czasu:

DateTimeOffset.UtcNow.ToUnixTimeSeconds()

Aby pobrać znacznik czasu z DateTime:

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

Można również użyć kleszczy. Koduję Dla Windows Mobile, więc nie mam pełnego zestawu metod. TotalSeconds nie jest dostępna dla mnie.

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

Lub

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

Tego używam:

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

Należy pamiętać, że ta metoda zwróci czas jako skoordynowany Czas uniwersalny (UTC).

Obcinanie {[1] } jest ważne, ponieważ jest zdefiniowane jako the value of the current System.TimeSpan structure expressed in whole fractional seconds.

A może rozszerzenie dla DateTime? Drugi jest prawdopodobnie bardziej mylący, że warto, dopóki nie istnieją rozszerzenia właściwości.

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

Po odjęciu 1970 od bieżącego czasu, należy pamiętać, że timespan najczęściej będzie miał niezerowe pole milisekund. Jeśli z jakiegoś powodu interesują Cię milisekundy, pamiętaj o tym.

 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.

Tego właśnie używam.

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

To rozwiązanie pomogło w mojej sytuacji:

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

Użycie helpera w kodzie:

double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)

Połączyłem ze sobą najbardziej eleganckie podejście do tej metody użytkowej:

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