C #에서 유닉스 타임 스탬프를 얻는 방법

나는 stackoverflow를 둘러 보았고 제안 된 질문 중 일부를 보았지만 아무도 대답하지 않는 것 같습니다 .C #에서 유닉스 타임 스탬프를 어떻게 얻습니까?

DateTime.UtcNow1970-01-01의 에포크 시간을 사용 하고 빼서 C #에서 유닉스 타임 스탬프를 얻습니다 .

예 :

Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;

DateTime.UtcNowDateTime유닉스 타임 스탬프를 가져 오려는 객체 로 대체 할 수 있습니다 .

이 필드,도 DateTime.UnixEpoch되고, 매우 가난하게 문서화 MSFT에 의해,하지만를 대체 할 수있다new DateTime(1970, 1, 1)

.NET 4.6부터는 DateTimeOffset.ToUnixTimeSeconds().

이것은 인스턴스 메소드이므로의 인스턴스에서 호출해야합니다 DateTimeOffset. 시간대를주의DateTime 하더라도 인스턴스를 캐스팅 할 수도 있습니다 .

현재 타임 스탬프를 얻으려면

DateTimeOffset.UtcNow.ToUnixTimeSeconds()

에서 타임 스탬프를 얻으려면 DateTime:

DateTime foo = DateTime.UtcNow;
long unixTime = ((DateTimeOffset)foo).ToUnixTimeSeconds();

진드기를 사용할 수도 있습니다. Windows Mobile을 코딩하고 있으므로 전체 방법이 없습니다. TotalSeconds 를 사용할 수 없습니다.

long epochTicks = new DateTime(1970, 1, 1).Ticks;
long unixTime = ((DateTime.UtcNow.Ticks - epochTicks) / TimeSpan.TicksPerSecond);

또는

TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
double unixTime = unixTicks.TotalSeconds;

이것이 내가 사용하는 것입니다 :

public long UnixTimeNow()
{
    var timeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
    return (long)timeSpan.TotalSeconds;
}

이 방법은 시간을 협정 세계시 (UTC)로 반환합니다.

잘림 .TotalSeconds은 다음과 같이 정의되므로 중요합니다the value of the current System.TimeSpan structure expressed in whole fractional seconds.

그리고 확장 기능은 DateTime어떻습니까? 두 번째는 속성 확장이 존재할 때까지 가치가 있다는 것이 더 혼란 스러울 것입니다.

/// <summary>
/// Converts a given DateTime into a Unix timestamp
/// </summary>
/// <param name="value">Any DateTime</param>
/// <returns>The given DateTime in Unix timestamp format</returns>
public static int ToUnixTimestamp(this DateTime value)
{
    return (int)Math.Truncate((value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

/// <summary>
/// Gets a Unix timestamp representing the current moment
/// </summary>
/// <param name="ignored">Parameter ignored</param>
/// <returns>Now expressed as a Unix timestamp</returns>
public static int UnixTimestamp(this DateTime ignored)
{
    return (int)Math.Truncate((DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

현재 시간에서 1970을 빼면 시간 범위에 0이 아닌 밀리 초 필드가있는 경우가 가장 많습니다. 어떤 이유로 든 밀리 초에 관심이 있다면 이것을 명심하십시오.

이 문제를 해결하기 위해 내가 한 일은 다음과 같습니다.

 DateTime now = UtcNow();

 // milliseconds Not included.
 DateTime nowToTheSecond = new DateTime(now.Year,now.Month,now.Day,now.Hour,now.Minute,now.Second); 

 TimeSpan span = (date - new DateTime(1970, 1, 1, 0, 0, 0, 0));

 Assert.That(span.Milliseconds, Is.EqualTo(0)); // passes.

이것이 내가 사용하는 것입니다.

 public class TimeStamp
    {
        public Int32 UnixTimeStampUTC()
        {
            Int32 unixTimeStamp;
            DateTime currentTime = DateTime.Now;
            DateTime zuluTime = currentTime.ToUniversalTime();
            DateTime unixEpoch = new DateTime(1970, 1, 1);
            unixTimeStamp = (Int32)(zuluTime.Subtract(unixEpoch)).TotalSeconds;
            return unixTimeStamp;
        }
}

이 유틸리티 방법에 대한 가장 우아한 접근 방식을 결합했습니다.

public static class Ux {
    public static decimal ToUnixTimestampSecs(this DateTime date) => ToUnixTimestampTicks(date) / (decimal) TimeSpan.TicksPerSecond;
    public static long ToUnixTimestampTicks(this DateTime date) => date.ToUniversalTime().Ticks - UnixEpochTicks;
    private static readonly long UnixEpochTicks = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
}

이 솔루션은 내 상황에 도움이되었습니다.

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

코드에서 도우미 사용하기 :

double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)

시스템에 DateTimeOffset에 대한 ToUnixTimeMilliseconds가 있습니다

DateTime에 대해 비슷한 방법을 작성할 수 있습니다.

public static long ToUnixTimeSeconds(this DateTime value)
{
    return value.Ticks / 10000000L - 62135596800L;
}

10000000L-틱을 초로 변환

62135596800L-01.01.01을 01.01.1978로 변환

Utc 및 누수에 문제가 없습니다

다음은 다음을 지원하는 양방향 확장 클래스입니다.

• 시간대 현지화
• 초 또는 밀리 초 단위의 입력 / 출력.

OP의 경우 사용법은 다음과 같습니다.

DateTime.Now.ToUnixtime();

또는

DateTime.UtcNow.ToUnixtime();

직접적인 답변이 존재하지만 일반적인 접근 방식을 사용하는 것이 좋습니다. 특히 이와 같은 변환이 필요한 프로젝트이기 때문에 어쨌든 이러한 확장이 필요하므로 모두 동일한 도구를 사용하는 것이 좋습니다.

    public static class UnixtimeExtensions
    {
        public static readonly DateTime UNIXTIME_ZERO_POINT = new DateTime(1970, 1, 1, 0, 0,0, DateTimeKind.Utc);

        /// <summary>
        /// Converts a Unix timestamp (UTC timezone by definition) into a DateTime object
        /// </summary>
        /// <param name="value">An input of Unix timestamp in seconds or milliseconds format</param>
        /// <param name="localize">should output be localized or remain in UTC timezone?</param>
        /// <param name="isInMilliseconds">Is input in milliseconds or seconds?</param>
        /// <returns></returns>
        public static DateTime FromUnixtime(this long value, bool localize = false, bool isInMilliseconds = true)
        {
            DateTime result;

            if (isInMilliseconds)
            {
                result = UNIXTIME_ZERO_POINT.AddMilliseconds(value);
            }
            else
            {
                result = UNIXTIME_ZERO_POINT.AddSeconds(value);
            }

            if (localize)
                return result.ToLocalTime();
            else
                return result;
        }

        /// <summary>
        /// Converts a DateTime object into a Unix time stamp
        /// </summary>
        /// <param name="value">any DateTime object as input</param>
        /// <param name="isInMilliseconds">Should output be in milliseconds or seconds?</param>
        /// <returns></returns>
        public static long ToUnixtime(this DateTime value, bool isInMilliseconds = true)
        {
            if (isInMilliseconds)
            {
                return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalMilliseconds;
            }
            else
            {
                return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalSeconds;
            }
        }
    }

나는 잠시 동안 고군분투 한 후에 이것을 사용했으며, 시간대 오프셋에도 적합합니다.

    public double Convert_DatTime_To_UNIXDATETIME(DateTime dt)
    {
        System.DateTime from_date = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
        double unix_time_since = dt.Subtract(from_date).TotalMilliseconds;

        TimeSpan ts_offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow);

        double offset = ts_offset.TotalMilliseconds;

        return unix_time_since - offset;
    }

내가 사용하는 간단한 코드 :

public static long CurrentTimestamp()
{
   return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds * 1000);
}

이 코드는 1970-01-01 에서 현재 까지 총 밀리 초인 유닉스 타임 스탬프를 제공 합니다.