C #에서 에포크 시간을 어떻게 변환합니까?

C #에서 Unix epoch 시간 을 실시간으로 어떻게 변환 합니까? (1970 년 1 월 1 일 시작)

1970 년 1 월 1 일 자정 (UTC) 이후의 초 수로 정의되는 Unix 시간 을 의미한다고 가정합니다 .

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

닷넷 (V4.6)의 최신 버전은 단지 내장 추가 된 유닉스 시간 변환을 지원합니다. 여기에는 초 또는 밀리 초로 표시되는 유닉스 시간과 출발 시간이 모두 포함됩니다.

• 초 단위의 유닉스 시간 DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset 초 단위의 유닉스 시간 :

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• 밀리 초 단위의 유닉스 시간 DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset 밀리 초 단위의 유닉스 시간 :

long unixTimeStampInMilliseconds= dateTimeOffset.ToUnixTimeMilliseconds();

참고 :이 메소드는로 (과) 변환합니다 DateTimeOffset. DateTime표현 을 얻으려면 단순히 DateTimeOffset.DateTime속성을 사용하십시오 .

DateTime dateTime = dateTimeOffset.UtcDateTime;

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리턴한다 DateTimeA를 Kind의 Utc괜찮지 만, 위의 어떤은 ToUnixTime훨씬 더 의심 점에서 고려하지 않는 종류의 것입니다 DateTime주어진 date것입니다. 을 허용하기 위해 date의 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);
}

ToUniversalTimeLocal(또는 Unspecified) DateTime을 로 변환합니다 Utc.

DateTime에서 epoch로 이동할 때 epoch DateTime 인스턴스를 작성하지 않으려면 다음을 수행하십시오.

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

실제로는 초가 아닌 밀리 초 (밀리 초)를 추가하려고합니다. 초를 추가하면 범위를 벗어난 예외가 발생합니다.

더 나은 성능을 원하면이 버전을 사용할 수 있습니다.

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

net471 아래의 빠른 벤치 마크 (BenchmarkDotNet) 에서이 번호를 얻습니다.

        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 |

LukeH 버전 보다 2 배 빠름 (성능이 문제가되는 경우)

이것은 DateTime이 내부적으로 작동하는 방식과 유사합니다.

DateTimeOffset.ToUnixTimeMilliseconds () 메소드를 사용하십시오. 1970-01-01T00 : 00 : 00.000Z 이후 경과 된 밀리 초 수를 리턴합니다.

이것은 Framework 4.6 이상에서만 지원됩니다

var EPOCH = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

DateTimeOffset.ToUnixTimeMilliseconds에 잘 설명되어 있습니다.

다른 방법은 다음을 사용하는 것입니다.

long EPOCH = DateTime.UtcNow.Ticks - new DateTime(1970, 1, 1,0,0,0,0).Ticks;

초만으로 EPOCH를 얻으려면 다음을 사용할 수 있습니다

 var Epoch = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

다음 방법으로 Epoch를 로 변환하십시오.DateTime

private DateTime Epoch2UTCNow(int epoch) 
{
    return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(epoch); 
}

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

DateTime 개체에 ToUniversalTime ()을 사용해야합니다.

에포크 변환에 다음 확장 방법을 사용합니다.

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

    }

밀리 초 또는 초 사용에 대해 걱정하지 않으려면 다음을 수행하십시오.

    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 년에 밀리 초를 추가 할 수있는 방법이 없습니다.

4.6을 사용하지 않는 경우 소스 : 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;
    }    

경우 당신은 변환해야 timeval 형 구조체 포함 (초, 마이크로 초) 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);
}

.Net 4.6 이상에서는 DateTimeOffset.Now.ToUnixTimeSeconds ()를 사용하십시오.

내 해결책은 다음과 같습니다.

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