C # unix zaman damgası nasıl alınır

Stackoverflow etrafına baktım ve hatta önerilen soruların bazılarına baktım ve hiçbiri yanıt vermiyor gibi görünüyor, nasıl C # unix zaman damgası alıyorsunuz?

DateTime.UtcNow1970-01-01 dönemini kullanarak ve çıkararak C # 'da bir unix zaman damgası alırsınız .

Örneğin

Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;

DateTime.UtcNowDateTimeunix zaman damgasını almak istediğiniz herhangi bir nesneyle değiştirilebilir .

Orada bir alan, aynı zamanda DateTime.UnixEpochedilir çok kötü belgelenmiş MSFT tarafından değil yerini olabilirnew DateTime(1970, 1, 1)

.NET 4.6'dan itibaren vardır DateTimeOffset.ToUnixTimeSeconds().

Bu bir örnek yöntemidir, bu nedenle bunu bir örneğinde çağırmanız beklenir DateTimeOffset. Herhangi bir örneğini de yayınlayabilirsiniz DateTime, ancak saat dilimine dikkat edin .

Geçerli zaman damgasını almak için:

DateTimeOffset.UtcNow.ToUnixTimeSeconds()

Zaman damgasını aşağıdakilerden almak için DateTime:

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

Keneler de kullanabilirsiniz. Windows Mobile için kodlama yapıyorum, bu yüzden yöntemlerin tam setine sahip değilim. TotalSeconds benim için uygun değil.

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

veya

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

Ne kullanıyorum:

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

Bu yöntemin saati Eşgüdümlü Univeral Zaman (UTC) olarak döndüreceğini unutmayın.

Kesim .TotalSecondsönemlidir çünküthe value of the current System.TimeSpan structure expressed in whole fractional seconds.

Peki bir uzantıya ne dersiniz DateTime? İkincisi, özellik uzantıları var olana kadar değerinin muhtemelen daha kafa karıştırıcıdır.

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

1970'i şu anki zamandan çıkardığınızda, zaman aralığının çoğunlukla sıfır milisaniye olmayan bir alana sahip olacağını unutmayın. Herhangi bir nedenle milisaniye ile ilgileniyorsanız, bunu aklınızda bulundurun.

İşte bu sorunu çözmek için yaptım.

 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.

Ben bunu kullanıyorum.

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

Bu yardımcı yöntem için en zarif yaklaşımları bir araya getirdim:

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

Bu çözüm benim durumuma yardımcı oldu:

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

kodda yardımcı kullanarak:

double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)

Sistemde DateTimeOffset için bir ToUnixTimeMilliseconds var

DateTime için benzer bir yöntem yazabilirsiniz:

public static long ToUnixTimeSeconds(this DateTime value)
{
    return value.Ticks / 10000000L - 62135596800L;
}

10000000L - keneleri saniyeye dönüştürme

62135596800L - 01.01.01 ve 01.01.1978 arasında dönüştürme

Utc ve sızıntılarla ilgili bir sorun yok

Aşağıda aşağıdakileri destekleyen 2 yönlü bir uzantı sınıfı yer almaktadır:

• Saat dilimi yerelleştirmesi
• \ Output saniye veya milisaniye cinsinden girin.

OP durumunda, kullanım:

DateTime.Now.ToUnixtime();

veya

DateTime.UtcNow.ToUnixtime();

Doğrudan bir cevap olsa da, genel bir yaklaşım kullanmanın daha iyi olduğuna inanıyorum. Özellikle de böyle bir dönüşüme ihtiyaç duyan bir proje olduğu için yine de bu uzantılara ihtiyaç duyacağından, aynı aracı herkes için kullanmak daha iyidir.

    public static class UnixtimeExtensions
    {
        public static readonly DateTime UNIXTIME_ZERO_POINT = new DateTime(1970, 1, 1, 0, 0,0, DateTimeKind.Utc);

        /// <summary>
        /// Converts a Unix timestamp (UTC timezone by definition) into a DateTime object
        /// </summary>
        /// <param name="value">An input of Unix timestamp in seconds or milliseconds format</param>
        /// <param name="localize">should output be localized or remain in UTC timezone?</param>
        /// <param name="isInMilliseconds">Is input in milliseconds or seconds?</param>
        /// <returns></returns>
        public static DateTime FromUnixtime(this long value, bool localize = false, bool isInMilliseconds = true)
        {
            DateTime result;

            if (isInMilliseconds)
            {
                result = UNIXTIME_ZERO_POINT.AddMilliseconds(value);
            }
            else
            {
                result = UNIXTIME_ZERO_POINT.AddSeconds(value);
            }

            if (localize)
                return result.ToLocalTime();
            else
                return result;
        }

        /// <summary>
        /// Converts a DateTime object into a Unix time stamp
        /// </summary>
        /// <param name="value">any DateTime object as input</param>
        /// <param name="isInMilliseconds">Should output be in milliseconds or seconds?</param>
        /// <returns></returns>
        public static long ToUnixtime(this DateTime value, bool isInMilliseconds = true)
        {
            if (isInMilliseconds)
            {
                return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalMilliseconds;
            }
            else
            {
                return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalSeconds;
            }
        }
    }

Bunu bir süre mücadele ettikten sonra kullandım, saat dilimi ofsetine de hitap ediyor:

    public double Convert_DatTime_To_UNIXDATETIME(DateTime dt)
    {
        System.DateTime from_date = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
        double unix_time_since = dt.Subtract(from_date).TotalMilliseconds;

        TimeSpan ts_offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow);

        double offset = ts_offset.TotalMilliseconds;

        return unix_time_since - offset;
    }

Kullandığım basit kod:

public static long CurrentTimestamp()
{
   return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds * 1000);
}

Bu kod unix zaman damgasını veriyor, 1970-01-01'den bugüne toplam milisaniye .