Как вы конвертируете время эпохи в C#?

Question

Как конвертировать время эпохи Unix в C# в реальном времени? (Начало эпохи 01.01.1970)

Answer 1

Я предполагаю, что вы имеете в виду время Unix, которое определяется как количество секунд с полуночи (UTC) 1 января 1970 года.

public static DateTime FromUnixTime(long unixTime)
{
    return epoch.AddSeconds(unixTime);
}
private static readonly DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

Answer 2

В последней версии.Net (v4.6) добавлена ​​встроенная поддержка преобразования времени в Unix. Это включает в себя время от и до Unix, представленное в секундах или миллисекундах.

• Unix время в секундах до DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset Unix время в секундах:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Время Unix в миллисекундах до DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset Unix время в миллисекундах:

long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds();

---

Примечание. Эти методы конвертируются в и из DateTimeOffset, Чтобы получить DateTime представление просто использовать DateTimeOffset.DateTime имущество:

DateTime dateTime = dateTimeOffset.UtcDateTime;

Answer 3

С благодарностью LukeH я собрал несколько методов расширения для легкого использования:

public static DateTime FromUnixTime(this long unixTime)
{
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return epoch.AddSeconds(unixTime);
}

public static long ToUnixTime(this DateTime date)
{
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return Convert.ToInt64((date - epoch).TotalSeconds);
}

Обратите внимание на комментарий ниже от CodesInChaos, что выше FromUnixTime возвращает DateTime с Kind из Utc, что хорошо, но выше ToUnixTime гораздо более подозрительным в том, что не учитывает, какого рода DateTime данное date является. Чтобы разрешить date "s Kind быть либо Utc или же Local использовать ToUniversalTime:

public static long ToUnixTime(this DateTime date)
{
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return Convert.ToInt64((date.ToUniversalTime() - epoch).TotalSeconds);
}

ToUniversalTime преобразует Local (или же Unspecified) DateTime в Utc,

если вы не хотите создавать экземпляр DateTime эпохи при переходе от DateTime к эпохе, вы также можете сделать следующее:

public static long ToUnixTime(this DateTime date)
{
    return (date.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
}

Answer 4

Вы действительно хотите добавить миллисекунды (миллисекунды), а не секунды. Добавление секунд даст вам исключение вне диапазона.

Answer 5

Используйте метод DateTimeOffset.ToUnixTimeMilliseconds(). Возвращает количество миллисекунд, прошедших с 1970-01-01T00:00:00.000Z.

Это поддерживается только в Framework 4.6 или выше

var EPOCH = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

Это хорошо задокументировано здесь DateTimeOffset.ToUnixTimeMilliseconds

Answer 6

Если вы хотите лучшую производительность, вы можете использовать эту версию.

public const long UnixEpochTicks = 621355968000000000;
public const long TicksPerMillisecond = 10000;
public const long TicksPerSecond = TicksPerMillisecond * 1000;

//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static DateTime FromUnixTimestamp(this long unixTime)
{
    return new DateTime(UnixEpochTicks + unixTime * TicksPerSecond);
}

Из быстрого теста (BenchmarkDotNet) под net471 я получаю этот номер:

        Method |     Mean |     Error |    StdDev | Scaled |
-------------- |---------:|----------:|----------:|-------:|
         LukeH | 5.897 ns | 0.0897 ns | 0.0795 ns |   1.00 |
      MyCustom | 3.176 ns | 0.0573 ns | 0.0536 ns |   0.54 |

В 2 раза быстрее по сравнению с версией LukeH (если производительность зависит)

Это похоже на внутреннюю работу DateTime.

Answer 7

// convert datetime to unix epoch seconds
public static long ToUnixTime(DateTime date)
{
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    return Convert.ToInt64((date.ToUniversalTime() - epoch).TotalSeconds);
}

Следует использовать ToUniversalTime() для объекта DateTime.

Answer 8

В настоящее время вы можете просто использовать

DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()

он будет возвращен в виде 64-битной длины

Answer 9

Я использую следующие методы расширения для преобразования эпох

public static int GetEpochSeconds(this DateTime date)
    {
        TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1);
        return (int)t.TotalSeconds;
    }

public static DateTime FromEpochSeconds(this DateTime date, long EpochSeconds)
    {
        var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        return epoch.AddSeconds(EpochSeconds);

    }

Answer 10

Начиная с.Net 4.6 и выше используйте DateTimeOffset.Now.ToUnixTimeSeconds()

Answer 11

Чтобы не беспокоиться об использовании миллисекунд или секунд, просто выполните:

    public static DateTime _ToDateTime(this long unixEpochTime)
    {
        DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        var date = epoch.AddMilliseconds(unixEpochTime);

        if (date.Year > 1972)
            return date;

        return epoch.AddSeconds(unixEpochTime);
    }

Если время эпохи выражается в секундах, вы не сможете передать 1972 год, добавляя миллисекунды.

Answer 12

Если вы не используете 4.6, это может помочь Source: System.IdentityModel.Tokens

    /// <summary>
    /// DateTime as UTV for UnixEpoch
    /// </summary>
    public static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);

    /// <summary>
    /// Per JWT spec:
    /// Gets the number of seconds from 1970-01-01T0:0:0Z as measured in UTC until the desired date/time.
    /// </summary>
    /// <param name="datetime">The DateTime to convert to seconds.</param>
    /// <remarks>if dateTimeUtc less than UnixEpoch, return 0</remarks>
    /// <returns>the number of seconds since Unix Epoch.</returns>
    public static long GetIntDate(DateTime datetime)
    {
        DateTime dateTimeUtc = datetime;
        if (datetime.Kind != DateTimeKind.Utc)
        {
            dateTimeUtc = datetime.ToUniversalTime();
        }

        if (dateTimeUtc.ToUniversalTime() <= UnixEpoch)
        {
            return 0;
        }

        return (long)(dateTimeUtc - UnixEpoch).TotalSeconds;
    }    

Answer 13

DateTime от времени эпохи (в секундах).

      DateTime dateTime = EpochTime.DateTime(unixEpoch)

Получает количество секунд из 1970-01-01T0:0:0Z.

      long unixEpoch = EpochTime.GetIntDate(dateTime);

Пространство имен:Microsoft.IdentityModel.Tokens

Answer 14

Если вам нужно преобразовать временную структуру (секунды, микросекунды), содержащую UNIX time в 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);
}

Answer 15

Вот мое решение:

public long GetTime()
{
    DateTime dtCurTime = DateTime.Now.ToUniversalTime();

    DateTime dtEpochStartTime = Convert.ToDateTime("1/1/1970 0:00:00 AM");

    TimeSpan ts = dtCurTime.Subtract(dtEpochStartTime);

    double epochtime;

    epochtime = ((((((ts.Days * 24) + ts.Hours) * 60) + ts.Minutes) * 60) + ts.Seconds);   

    return Convert.ToInt64(epochtime);
}