如何将 Unix 时间戳转换为 DateTime，反之亦然？

这是您需要的：

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

或者，对于 Java（这是不同的，因为时间戳以毫秒为单位，而不是秒）：

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

---

latest version of .NET (v4.6) 添加了对 Unix 时间转换的内置支持。这包括以秒或毫秒表示的往返 Unix 时间。

以秒为单位的 UTC DateTimeOffset 的 Unix 时间：

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

DateTimeOffset 以秒为单位的 Unix 时间：

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

以毫秒为单位的 Unix 时间到 UTC DateTimeOffset：

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

DateTimeOffset 以毫秒为单位的 Unix 时间：

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

注意：这些方法与 UTC DateTimeOffset 相互转换。要获得 DateTime 表示，只需使用 DateTimeOffset.UtcDateTime 或 DateTimeOffset.LocalDateTime 属性：

DateTime dateTime = dateTimeOffset.UtcDateTime;

---

DateTime 到 UNIX 时间戳：

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

---

从 Wikipedia：

UTC 不会随着季节的变化而变化，但如果时区管辖区遵守夏令时（夏令时），当地时间或民用时间可能会发生变化。例如，美国东海岸的当地时间在冬季比 UTC 时间晚 5 小时，但在当地实行夏令时时比 UTC 时间晚 4 小时。

所以这是我的代码：

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

---

小心，如果您需要高于毫秒的精度！

.NET (v4.6) 方法（例如 FromUnixTimeMilliseconds）不提供这种精度。

AddSeconds 和 AddMilliseconds 也切断了双精度的微秒。

这些版本具有高精度：

Unix -> 日期时间

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

日期时间 -> 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;
}

---

您可以使用 DateTimeOffset。

例如。我有一个 DateTime 对象

var dateTime1 = DateTime.Now;

如果我想将其转换为Unix时间戳，可以如下实现

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

如果要将 unix timeStamp 转换为普通 DateTime，可以使用以下代码：

var dateTime2 = DateTimeOffset.FromUnixTimeSeconds(unixTimeSeconds).LocalDateTime;

或者

var dateTime2 = DateTimeOffset.FromUnixTimeSeconds(unixTimeSeconds).UtcDateTime;

欲了解更多信息，请访问此链接：

DateTimeOffset.ToUnixTimeSeconds Method，
DateTimeOffset.FromUnixTimeSeconds

---

请参阅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 的回答，我最近发现自己处于令人讨厌的场景中，即在输入数据集中任意混合了秒和毫秒 UNIX 时间戳。以下代码似乎可以很好地处理这个问题：

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 时间转换是 .NET Framework 4.6 中的新增功能。

您现在可以更轻松地将日期和时间值与 .NET Framework 类型和 Unix 时间相互转换。例如，在 JavaScript 客户端和 .NET 服务器之间转换时间值时，这可能是必需的。 DateTimeOffset structure 中添加了以下 API：

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

---

Unix 纪元现在是 DateTime 类的一部分。将毫秒转换为 DateTime 就像

DateTime.UnixEpoch.AddMilliseconds(millis)

---

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

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

---

在 C# 8.0 (.NET Core 2.1) 中，它是一个简单的单行：

DateTime.UnixEpoch.AddSeconds(unixTimeInSeconds)

---

仅通过将转换与 1/1/1970 进行比较，没有本地时间调整，我就找到了正确的答案；

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;

---

从 .net 4.6 开始，您可以这样做：

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

---

编写了一个对我们有用的最简单的扩展。如果有人找...

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

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

---

System.DateTimeOffset.Now.ToUnixTimeSeconds()

---

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

当然，可以将 unixEpoch 设为全局静态，因此它只需要在您的项目中出现一次，如果 UNIX 时间以秒为单位，则可以使用 AddSeconds。

走另一条路：

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

根据需要截断为 Int64 和/或使用 TotalSeconds。

---

一个 Unix 滴答是 1 秒（如果我没记错的话），一个 .NET 滴答是 100 纳秒。

如果您遇到纳秒问题，您可能想尝试使用 AddTick(10000000 * value)。

---

我需要将包含 UNIX time 的 timeval struct（秒，微秒）转换为 DateTime 而不会丢失精度，并且在这里没有找到答案，所以我想我可以添加我的：

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

---

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(double datetime))

---

对于 .NET 4.6 及更高版本：

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

---