Unix zaman damgasını DateTime'a veya tam tersine nasıl dönüştürebilirim?

Bu örnek kod var, ancak milisaniye / nanosaniye problemleri hakkında konuşmaya başlıyor.

Aynı soru MSDN, C # Unix çağından beri saniye .

Şimdiye kadar aldığım şey bu:

public Double CreatedEpoch
{
  get
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    TimeSpan span = (this.Created.ToLocalTime() - epoch);
    return span.TotalSeconds;
  }
  set
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    this.Created = epoch.AddSeconds(value);
  }
}

İhtiyacınız olan şey:

public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )
{
    // Unix timestamp is seconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();
    return dtDateTime;
}

Veya, Java için (zaman damgası saniyeler değil milisaniye cinsinden olduğu için farklıdır):

public static DateTime JavaTimeStampToDateTime( double javaTimeStamp )
{
    // Java timestamp is milliseconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddMilliseconds( javaTimeStamp ).ToLocalTime();
    return dtDateTime;
}

NET (V4.6) en son sürümü ekledi yerleşik Unix zaman dönüşümleri için destek. Bu, saniye veya milisaniye ile gösterilen Unix zamanına ve Unix zamanını içerir.

• UTC'ye kadar saniye cinsinden Unix süresi DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset saniye cinsinden Unix zamanı:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Milisaniye cinsinden Unix süresi UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset milisaniye cinsinden Unix zamanı:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Not: Bu yöntemler UTC'ye ve UTC'den dönüşür DateTimeOffset. DateTimeTemsil almak için DateTimeOffset.UtcDateTimeveya DateTimeOffset.LocalDateTimeözelliklerini kullanmanız yeterlidir :

DateTime dateTime = dateTimeOffset.UtcDateTime;

DateTime - UNIX zaman damgası:

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

Gönderen Vikipedi :

UTC mevsim değişikliği ile değişmez, ancak bir saat dilimi yargılaması yaz saatine (yaz saati) uyuyorsa yerel saat veya sivil saat değişebilir. Örneğin, Amerika Birleşik Devletleri'nin doğu kıyısındaki yerel saat, kışın UTC'nin beş saat gerisindedir, ancak gün ışığından yararlanma gözlemlenirken dört saat geridedir.

Yani bu benim kodum:

TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;

Milisaniyeden daha yüksek bir hassasiyete ihtiyacınız varsa dikkatli olun!

.NET (v4.6) yöntemleri (örn. FromUnixTimeMilliseconds ) bu hassasiyeti sağlamaz.

AddSeconds ve AddMilliseconds da çiftte mikrosaniye keser.

Bu sürümler yüksek hassasiyete sahiptir:

Unix -> DateTime

public static DateTime UnixTimestampToDateTime(double unixTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (long) (unixTime * TimeSpan.TicksPerSecond);
    return new DateTime(unixStart.Ticks + unixTimeStampInTicks, System.DateTimeKind.Utc);
}

DateTime -> Unix

public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (dateTime.ToUniversalTime() - unixStart).Ticks;
    return (double) unixTimeStampInTicks / TimeSpan.TicksPerSecond;
}

Bkz. IdentityModel.EpochTimeExtensions

public static class EpochTimeExtensions
{
    /// <summary>
    /// Converts the given date value to epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTime dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given date value to epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTimeOffset dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given epoch time to a <see cref="DateTime"/> with <see cref="DateTimeKind.Utc"/> kind.
    /// </summary>
    public static DateTime ToDateTimeFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddTicks(timeInTicks);
    }

    /// <summary>
    /// Converts the given epoch time to a UTC <see cref="DateTimeOffset"/>.
    /// </summary>
    public static DateTimeOffset ToDateTimeOffsetFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddTicks(timeInTicks);
    }
}

ScottCher'in cevabını desteklemek için, son zamanlarda kendimi hem girdi hem de milisaniye UNIX zaman damgalarının keyfi bir şekilde bir girdi veri kümesinde karıştırılması rahatsız edici senaryosunda buldum. Aşağıdaki kod bu iyi işliyor gibi görünüyor:

static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
static readonly double MaxUnixSeconds = (DateTime.MaxValue - UnixEpoch).TotalSeconds;

public static DateTime UnixTimeStampToDateTime(double unixTimeStamp)
{
   return unixTimeStamp > MaxUnixSeconds
      ? UnixEpoch.AddMilliseconds(unixTimeStamp)
      : UnixEpoch.AddSeconds(unixTimeStamp);
}

Unix zaman dönüşümü .NET Framework 4.6'da yenidir.

Artık tarih ve saat değerlerini .NET Framework türlerine ve Unix saatlerine veya daha kolay dönüştürebilirsiniz. Bu, örneğin bir JavaScript istemcisi ve .NET sunucusu arasında zaman değerlerini dönüştürürken gerekli olabilir. DateTimeOffset yapısına aşağıdaki API'lar eklendi :

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()

Sadece 1/1/1970 ile yerel saat ayarlaması arasındaki dönüşümü karşılaştırarak doğru cevabı buldum;

DateTime date = new DateTime(2011, 4, 1, 12, 0, 0, 0);
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);
TimeSpan span = (date - epoch);
double unixTime =span.TotalSeconds;

var dt = DateTime.Now; 
var unixTime = ((DateTimeOffset)dt).ToUnixTimeSeconds();

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

// [11.11.2017 10:43:11 +00: 00]

.Net 4.6'dan şunları yapabilirsiniz:

var dateTime = DateTimeOffset.FromUnixTimeSeconds(unixDateTime).DateTime;

DateTime unixEpoch = DateTime.ParseExact("1970-01-01", "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
DateTime convertedTime = unixEpoch.AddMilliseconds(unixTimeInMillisconds);

Tabii ki, unixEpochbir global statik yapabilir, bu yüzden projenizde sadece bir kez görünmesi gerekir AddSecondsve UNIX zamanı saniyeler içinde kullanılabilir.

Diğer yoldan gitmek için:

double unixTimeInMilliseconds = timeToConvert.Subtract(unixEpoch).TotalMilliseconds;

Int64'e kısaltın ve / veya TotalSecondsgerektiği gibi kullanın .

Bizim için çalışan en basit bir uzantı yazdı. Biri ararsa ...

public static class DateTimeExtensions
{
    public static DateTime FromUnixTimeStampToDateTime(this string unixTimeStamp)
    {

        return DateTimeOffset.FromUnixTimeSeconds(long.Parse(unixTimeStamp)).UtcDateTime;
    }
}

System.DateTimeOffset.Now.ToUnixTimeSeconds()

Unix kene 1 saniyedir (iyi hatırlıyorsam) ve .NET kene 100 nanosaniyedir.

Nanosaniye ile ilgili sorun yaşıyorsanız AddTick (10000000 * değeri) kullanmayı denemek isteyebilirsiniz.

Ben dönüştürmek için gerekli timeval yapı içeren (saniye, mikrosaniye) UNIX timeiçin DateTimehassas kaybetmeden ve ben sadece benimkini eklemek düşündüm işte bir cevap bulamadım:

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

DateTimeOffset kullanabilirsiniz .

Örneğin. DateTime nesnesim var

var dateTime=new DateTime();

Bunu Unix zaman damgalarına dönüştürmek istersem, aşağıdaki gibi başarılabilirim

var unixTimeSeconds= new DateTimeOffset(dateTime).ToUnixTimeSeconds()

Daha fazla bilgi için lütfen şu bağlantıyı ziyaret edin: DateTimeOffset.ToUnixTimeSeconds Yöntemi

public static class UnixTime
    {
        private static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);

        public static DateTime UnixTimeToDateTime(double unixTimeStamp)
        {
            return Epoch.AddSeconds(unixTimeStamp).ToUniversalTime();
        }
    }

UnixTime.UnixTimeToDateTime (çift datetime))

.NET 4.6 ve üstü için:

public static class UnixDateTime
{
    public static DateTimeOffset FromUnixTimeSeconds(long seconds)
    {
        if (seconds < -62135596800L || seconds > 253402300799L)
            throw new ArgumentOutOfRangeException("seconds", seconds, "");

        return new DateTimeOffset(seconds * 10000000L + 621355968000000000L, TimeSpan.Zero);
    }

    public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
    {
        if (milliseconds < -62135596800000L || milliseconds > 253402300799999L)
            throw new ArgumentOutOfRangeException("milliseconds", milliseconds, "");

        return new DateTimeOffset(milliseconds * 10000L + 621355968000000000L, TimeSpan.Zero);
    }

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

    public static long ToUnixTimeMilliseconds(this DateTimeOffset utcDateTime)
    {
        return utcDateTime.Ticks / 10000L - 62135596800000L;
    }

    [Test]
    public void UnixSeconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInSeconds = utcNowOffset.ToUnixTimeSeconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeSeconds(unixTimestampInSeconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
    }

    [Test]
    public void UnixMilliseconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInMilliseconds = utcNowOffset.ToUnixTimeMilliseconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeMilliseconds(unixTimestampInMilliseconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
        Assert.AreEqual(utcNowOffset.Millisecond, utcNowOffsetTest.Millisecond);
    }
}