Odtnhj

The latest version of .NET (v4.6) has added built-in support for Unix time conversions. That includes both to and from Unix time represented by either seconds or milliseconds.

• Unix time in seconds to UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• 
  DateTimeOffset to Unix time in seconds:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• Unix time in milliseconds to UTC DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• 
  DateTimeOffset to Unix time in milliseconds:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

Note: These methods convert to and from a UTC DateTimeOffset. To get a DateTime representation simply use the DateTimeOffset.UtcDateTime or DateTimeOffset.LocalDateTime properties:

DateTime dateTime = dateTimeOffset.UtcDateTime;

DateTime to UNIX timestamp:

public static double DateTimeToUnixTimestamp(DateTime dateTime)

 return (TimeZoneInfo.ConvertTimeToUtc(dateTime) - 
 new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).TotalSeconds;

"UTC does not change with a change of seasons, but local time or civil time may change if a time zone jurisdiction observes daylight saving time (summer time). For example, UTC is 5 hours ahead of (that is, later in the day than) local time on the east coast of the United States during winter, but 4 hours ahead while daylight saving is observed there."

So this is my code:

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

Be careful, if you need precision higher than milliseconds!

.NET (v4.6) methods (e.g. FromUnixTimeMilliseconds) don't provide this precision.

AddSeconds and AddMilliseconds also cut off the microseconds in the double.

These versions have high precision:

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;

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

To supplement ScottCher's answer, I recently found myself in the annoying scenario of having both seconds and milliseconds UNIX timestamps arbitrarily mixed together in an input data set. The following code seems to handle this well:

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 time conversion is new in .NET Framework 4.6.

You can now more easily convert date and time values to or from .NET Framework types and Unix time. This can be necessary, for example, when converting time values between a JavaScript client and .NET server. The following APIs have been added to the DateTimeOffset structure:

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

I found the right answer just by comparing the conversion to 1/1/1970 w/o the local time adjustment;

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;

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

Of course, one can make unixEpoch a global static, so it only needs to appear once in your project, and one can use AddSeconds if the UNIX time is in seconds.

To go the other way:

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

Truncate to Int64 and/or use TotalSeconds as needed.

A Unix tick is 1 second (if I remember well), and a .NET tick is 100 nanoseconds.

If you've been encountering problems with nanoseconds, you might want to try using AddTick(10000000 * value).

I needed to convert a timeval struct (seconds, microseconds) containing UNIX time to DateTime without losing precision and haven't found an answer here so I thought I just might add mine:

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

you can call UnixTime.UnixTimeToDateTime(double datetime))

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

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

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

For .NET 4.6 and later:

public static class UnixDateTime

 public static DateTimeOffset FromUnixTimeSeconds(long seconds)
 

 public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
 
 if (milliseconds < -62135596800000L 

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