Bagaimana saya bisa mengubah cap waktu Unix ke DateTime dan sebaliknya?

Ada contoh kode ini, tetapi kemudian mulai berbicara tentang masalah milidetik / nanodetik.

Pertanyaan yang sama ada di MSDN, Detik sejak zaman Unix di C # .

Inilah yang saya dapatkan sejauh ini:

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

Inilah yang Anda butuhkan:

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

Atau, untuk Java (yang berbeda karena cap waktu dalam milidetik, bukan detik):

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

Versi terbaru .NET (v4.6) telah menambahkan dukungan bawaan untuk konversi waktu Unix. Itu termasuk ke dan dari waktu Unix yang diwakili oleh detik atau milidetik.

• Batalkan waktu dalam detik ke UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset ke waktu Unix dalam detik:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Unix waktu dalam milidetik ke UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset hingga waktu Unix dalam milidetik:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Catatan: Metode ini dikonversi ke dan dari UTC DateTimeOffset. Untuk mendapatkan DateTimerepresentasi cukup gunakan DateTimeOffset.UtcDateTimeatau DateTimeOffset.LocalDateTimeproperti:

DateTime dateTime = dateTimeOffset.UtcDateTime;

Stempel DateTime ke UNIX:

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

Dari Wikipedia :

UTC tidak berubah dengan perubahan musim, tetapi waktu setempat atau waktu sipil dapat berubah jika yurisdiksi zona waktu mengamati waktu musim panas (waktu musim panas). Sebagai contoh, waktu lokal di pantai timur Amerika Serikat adalah lima jam di belakang UTC selama musim dingin, tetapi empat jam di belakang sementara penghematan siang hari diamati di sana.

Jadi ini kode saya:

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

Hati-hati, jika Anda membutuhkan ketelitian yang lebih tinggi dari milidetik!

Metode .NET (v4.6) (mis. FromUnixTimeMilliseconds ) tidak memberikan ketepatan ini.

AddSeconds dan AddMilliseconds juga memotong mikrodetik di ganda.

Versi ini memiliki presisi tinggi:

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

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

Untuk melengkapi jawaban ScottCher, saya baru-baru ini menemukan diri saya dalam skenario yang menyebalkan memiliki kedua cap waktu UNIX detik dan milidetik dicampur secara sewenang-wenang dalam satu set data input. Kode berikut tampaknya menangani ini dengan baik:

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

Konversi waktu unix adalah baru di .NET Framework 4.6.

Anda sekarang dapat dengan lebih mudah mengonversi nilai tanggal dan waktu ke atau dari jenis .NET Framework dan waktu Unix. Ini bisa diperlukan, misalnya, ketika mengonversi nilai waktu antara klien JavaScript dan server .NET. API berikut telah ditambahkan ke struktur DateTimeOffset :

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

Saya menemukan jawaban yang tepat hanya dengan membandingkan konversi ke 1/1/1970 tanpa penyesuaian waktu setempat;

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]

Dari .net 4.6, Anda dapat melakukan ini:

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

Tentu saja, seseorang dapat membuat unixEpochstatis global, jadi itu hanya perlu muncul sekali dalam proyek Anda, dan satu dapat digunakan AddSecondsjika waktu UNIX dalam detik.

Untuk pergi ke arah lain:

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

Potong ke Int64 dan / atau gunakan TotalSecondssesuai kebutuhan.

Ditulis ekstensi paling sederhana yang berfungsi untuk kita. Jika ada yang mencarinya ...

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

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

System.DateTimeOffset.Now.ToUnixTimeSeconds()

Kutu Unix adalah 1 detik (jika saya ingat dengan baik), dan kutu .NET adalah 100 nanodetik.

Jika Anda pernah mengalami masalah dengan nanodetik, Anda mungkin ingin mencoba menggunakan AddTick (nilai 10000000 *).

Yang saya butuhkan untuk mengkonversi struct timeval (detik, mikrodetik) mengandung UNIX timeke DateTimetanpa kehilangan presisi dan belum menemukan jawaban di sini jadi saya pikir saya hanya bisa menambahkan saya:

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

Anda dapat menggunakan DateTimeOffset .

Sebagai contoh. Saya memiliki objek DateTime

var dateTime=new DateTime();

Jika saya ingin mengonversikannya ke waktu prangko Unix, saya dapat mencapai sebagai berikut

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

Untuk informasi lebih lanjut silakan kunjungi tautan ini: DateTimeOffset.ToUnixTimeSeconds Method

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

Anda dapat menghubungi UnixTime.UnixTimeToDateTime (double datetime))

Untuk .NET 4.6 dan yang lebih baru:

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