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

【问题标题】：How can I convert a Unix timestamp to DateTime and vice versa?如何将 Unix 时间戳转换为 DateTime，反之亦然？
【发布时间】：2021-08-31 16:54:57
【问题描述】：

有这个示例代码，但它开始谈论毫秒/纳秒问题。

MSDN 上有同样的问题，Seconds since the Unix epoch in C#。

这是我目前所得到的：

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

【问题讨论】：

即将推出的 .NET 4.6（将于今年晚些时候发布）引入了对此的支持。请参阅 DateTimeOffset.FromUnixTimeSeconds 和 DateTimeOffset.ToUnixTimeSeconds 方法。也有毫秒 unix-time 的方法。
另一个添加是DateTime.UnixEpoch。除非你需要DateTimeOffset 而不是DateTime，否则我认为DateTime.UnixEpoch.AddMilliseconds(...) 的可读性比DateTimeOffset.FromUnixTimeMilliseconds(...).UtcDateTime 略好。

标签： c# datetime unix epoch data-conversion

【解决方案1】：

这是你需要的：

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

【讨论】：

Windows 中的时间由 HAL 处理，仅在 1ms 到 15ms 内接近准确。更多信息可在第 112 页左右的Windows Internals 中找到，如果有人感兴趣的话。
这个答案有截断秒数的风险......双精度数是一个浮点数。参数应该是 int/long/etc.
这些方法应该接受 long 或 int，而不是 double。此外，对于 Java 时间戳，不需要除以 1000 和四舍五入。就做dtDateTime.AddMilliseconds(javaTimeStamp).ToLocalTime();
您是否错过了“反之亦然”？我们如何将 DateTime 转换为时间戳？
对于 .NET Framework 4.6 及更高版本，现在有 static DateTimeOffset.FromUnixMilliseconds 和 DateTimeOffset.ToUnixMilliseconds。

【解决方案2】：

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

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

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

DateTimeOffset 以秒为单位的 Unix 时间：

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

以毫秒为单位的 UTC 时间 DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

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

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

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

DateTime dateTime = dateTimeOffset.UtcDateTime;

【讨论】：

docs.microsoft.com/en-us/dotnet/api/…
这不会将时间转换为本地时间。如果你使用 DateTimeOffset.FromUnixTimeSeconds()，你会得到 UTC。
@BerenddeBoer 如果需要，您可以使用ToLocalTime。
要获取当前时间，您可以使用long unixMilliseconds = DateTimeOffset.Now.ToUnixTimeMilliseconds();
绝对质量的答案。

【解决方案3】：

日期时间到 UNIX 时间戳：

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

【讨论】：

如果我从本地主机的云中运行，我会得到不同的结果。有道理吗？

【解决方案4】：

来自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;

【讨论】：

但这会返回一个双精度值，我想需要转换成 long 吗？

【解决方案5】：

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

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

【讨论】：

这是正确答案。其他人在从时间戳转换回来时得到的时区不正确。
对于 DateTime->Java，只需 [code] 返回 (long) unixTimeStampInTicks / TimeSpan.TicksPerMilliSecond; [/code]

【解决方案6】：

您可以使用 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;

【讨论】：

如果你真的想要 Now 作为 UNIX 时间，你可以使用 DateTimeOffset.UtcNow.ToUnixTimeSeconds()

【解决方案7】：

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

【讨论】：

这很好，但我建议做一个小改动：使用“long”类型应该改为“Int32”或“int”。 “长”意味着有显着的精度，但没有。所有的数学运算都只精确到 1 秒，因此 Int32 更能暗示您对 Unix 时间戳的期望
我认为这是因为 DateTime.Ticks 是 Int64（长），所以他们避免了额外的未经检查的演员表。

【解决方案8】：

为了补充 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);
}

【讨论】：

不使用 DateTimeKind 参数时要小心，因为构造的 DateTime 将是计算机的本地时间（感谢代码，Chris）！
当心 - 如果 1978 年 1 月 11 日之前的日期以毫秒为单位，这将不适用于 unix 时间戳。 Unix 日期戳 253324800（秒）给出正确的日期 11.01.1978，而毫秒表示 253324800000 给出的日期是 18.07.9997。这可能适用于您的数据集，但不是通用解决方案。

【解决方案9】：

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

【讨论】：

这不是给你当地时间，你得到的是UTC。
@BerenddeBoer 这是一个合理的默认值。您可以根据需要应用自定义偏移量。
@BerenddeBoer 这误解了 unix 时间是什么。 Unix 时间是自 UTC 1970 年 1 月 1 日午夜以来的秒数。无论您身在何处，自那个时代以来的秒数都不会改变。将其转换为人类可读的本地时间显示与这种通用表示是分开的，因为它应该是。

【解决方案10】：

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

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

【讨论】：

【解决方案11】：

我只是通过将转换与 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;

【讨论】：

【解决方案12】：

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

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

【讨论】：

【解决方案13】：

编写了一个适合我们的最简单的扩展程序。如果有人找...

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

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

【讨论】：

【解决方案14】：

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

DateTime.UnixEpoch.AddMilliseconds(millis)

【讨论】：

【解决方案15】：

System.DateTimeOffset.Now.ToUnixTimeSeconds()

【讨论】：

【解决方案16】：

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

DateTime.UnixEpoch.AddSeconds(unixTimeInSeconds)

【讨论】：

【解决方案17】：

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。

【讨论】：

【解决方案18】：

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

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

【讨论】：

Unix 已经过了纪元的秒数 - 即 70 年 1 月 1 日。

【解决方案19】：

我需要将包含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);
}

【讨论】：

【解决方案20】：

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

【讨论】：

【解决方案21】：

对于 .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);
    }
}

【讨论】：

我不明白。在 .NET 4.6 中，BCL 已经拥有这些方法（例如，请参阅我对上述问题的评论，或其他一些新答案（2015 年）。那么再次编写它们的重点是什么？你的意思是你的答案是之前到 4.6 版本的解决方案？