Как преобразовать временную метку Unix в DateTime и наоборот?

Там есть пример кода, но потом он начинает говорить о проблемах миллисекунд/наносекунд.

Тот же вопрос есть на MSDN, Секунды с эпохи Unix в 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);
  }
}
Peter Mortensen
Редактировал вопрос 15-го января 2018 в 8:36
Программирование
datetime c# unix data-conversion epoch
30-го октября 2008 в 10:30
32 просмотров
Комментарии к вопросу (1)
Решение

Вот что вам нужно:

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

Или для Java (что отличается тем, что метка времени указывается в миллисекундах, а не в секундах):

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;
}
Комментарии (12)

В последней версии .Чистый (В4.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. Чтобы получить представление Датавремя просто использовать значения DateTimeOffset.UtcDateTimeилитипа DateTimeOffset.Свойства LocalDateTime`:

DateTime dateTime = dateTimeOffset.UtcDateTime;
samlh
Редактировал ответ 21-го июня 2018 в 2:16
Комментарии (4)

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;
}
Комментарии (0)

Из Википедия:

по UTC не меняется со сменой сезонов, но по местному времени или гражданского времени может измениться, если время юрисдикции часовом поясе применяется переход на летнее время (летнее время). Например, по местному времени на восточном побережье США в пять часов отстает от UTC зимой, но четыре часа позади в летнее время там наблюдается.

Так что это мой код:

TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;
Pang
Редактировал ответ 31-го июля 2019 в 1:20
Комментарии (1)

Будьте осторожны, если вам нужна точность выше, чем миллисекунды!

.Чистый (В4.6) методы (например, FromUnixTimeMilliseconds) Дон'т обеспечить эту точность.

AddSeconds и AddMilliseconds также отрезать микросекунд в двойном.

Эти версии имеют высокую точность:

В Unix -и GT; Датавремя

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;
}
Felix Keil
Редактировал ответ 19-го февраля 2018 в 8:50
Комментарии (4)

См IdentityModel.EpochTimeExtensions

public static class EpochTimeExtensions
{
    /// 
    /// Converts the given date value to epoch time.
    /// 
    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;
    }

    /// 
    /// Converts the given date value to epoch time.
    /// 
    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;
    }

    /// 
    /// Converts the given epoch time to a  with  kind.
    /// 
    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);
    }

    /// 
    /// Converts the given epoch time to a UTC .
    /// 
    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);
    }
}
Комментарии (2)

В дополнение к 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);
}
Комментарии (2)

Преобразование Unix время новые .Net фреймворк 4.6.

Теперь вы можете легко конвертировать даты и значения времени или от .Чистая Framework и Unix время. Это может потребоваться, например, при преобразовании значения времени между JavaScript-клиента и .Чистый сервер. Следующие API были добавлены к структуры DateTimeOffset:

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()
Elanis
Редактировал ответ 17-го апреля 2019 в 8:22
Комментарии (3)

Я нашел правильный ответ, просто сравнив пересчет на 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;
Комментарии (0)
var dt = DateTime.Now; 
var unixTime = ((DateTimeOffset)dt).ToUnixTimeSeconds();

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

Комментарии (0)
 
DateTime unixEpoch = DateTime.ParseExact("1970-01-01", "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
DateTime convertedTime = unixEpoch.AddMilliseconds(unixTimeInMillisconds);

Конечно, можно сделать unixEpochглобальный статический, поэтому его нужно только один раз в проекте, и можно использовать AddSeconds если время Unix-время в секундах.

Пойдем другим путем:

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

Усечь до int64 и/или использовать TotalSeconds по мере необходимости.

Комментарии (0)

Тик в Unix составляет 1 секунду (если я хорошо помню), а тик в .NET - 100 наносекунд.

Если у вас возникли проблемы с наносекундами, вы можете попробовать использовать AddTick(10000000 * value).

Комментарии (1)

От .объем 4.6, вы можете сделать это:

var dateTime = DateTimeOffset.FromUnixTimeSeconds(unixDateTime).DateTime;
Комментарии (0)

Мне нужно, чтобы преобразовать время структура (секунды, микросекунды), содержащие Unix время до Датавремя без потери точности и не'т нашли ответ здесь, так что я думал, я мог бы добавить от себя:

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);
}
Elanis
Редактировал ответ 17-го апреля 2019 в 6:53
Комментарии (0)
 
System.DateTimeOffset.Now.ToUnixTimeSeconds()
Комментарии (0)

Написал простое расширение, которое работает на нас. Если кто-то ищет его...

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

        return DateTimeOffset.FromUnixTimeSeconds(long.Parse(unixTimeStamp)).UtcDateTime;
    }
}
Комментарии (0)
 
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(двойной датавремя))

madan
Редактировал ответ 18-го июня 2018 в 7:43
Комментарии (0)

Для .Чистая 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);
    }
}
Комментарии (1)