Ik heb stackoverflow bekeken en zelfs enkele van de voorgestelde vragen bekeken en geen enkele lijkt te beantwoorden, hoe krijg je een Unix-tijdstempel in C#?
Antwoord 1, autoriteit 100%
Vanaf .NET 4.6 is er DateTimeOffset.ToUnixTimeSeconds.
Dit is een instantiemethode, dus er wordt van u verwacht dat u deze aanroept op een instantie van
DateTimeOffset. Je kunt ook elk exemplaar van DateTimecasten, hoewel pas op
de tijdzone. Om de huidige tijdstempel te krijgen:
DateTimeOffset.Now.ToUnixTimeSeconds()
Om de tijdstempel van een DateTimete krijgen:
DateTime foo = DateTime.Now;
long unixTime = ((DateTimeOffset)foo).ToUnixTimeSeconds();
Antwoord 2, autoriteit 87%
Je krijgt een Unix-tijdstempel in C# door DateTime.UtcNowen het tijdvak van 1970-01-01 aftrekken.
bijv.
Int32 unixTimestamp = (int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
DateTime.UtcNowkan worden vervangen door elk DateTime-object waarvoor u de Unix-tijdstempel wilt krijgen.
Er is ook een veld, DateTime.UnixEpoch, dat zeer slecht gedocumenteerddoor MSFT, maar kan een vervanging zijn voor new DateTime(1970, 1, 1)
Antwoord 3, autoriteit 6%
Je kunt ook teken gebruiken. Ik codeer voor Windows Mobile, dus ik heb niet de volledige set methoden. TotalSecondsis niet beschikbaar voor mij.
long epochTicks = new DateTime(1970, 1, 1).Ticks;
long unixTime = ((DateTime.UtcNow.Ticks - epochTicks) / TimeSpan.TicksPerSecond);
of
TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
double unixTime = unixTicks.TotalSeconds;
Antwoord 4, autoriteit 4%
Dit is wat ik gebruik:
public long UnixTimeNow()
{
var timeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
return (long)timeSpan.TotalSeconds;
}
Houd er rekening mee dat deze methode de tijd retourneert als Coordinated Universal Time (UTC).
Antwoord 5, autoriteit 3%
Het afkappen van .TotalSecondsis belangrijk omdat het wordt gedefinieerd als the value of the current System.TimeSpan structure expressed in whole fractional seconds.
En wat dacht je van een extensie voor DateTime? De tweede is waarschijnlijk meer verwarrend dan het waard is totdat er vastgoeduitbreidingen zijn.
/// <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);
}
Antwoord 6
Bijgewerkte code van Brad met een paar dingen:
Je hebt Math.truncate niet nodig, conversie naar int of long kapt de waarde automatisch af.
In mijn versie gebruik ik long in plaats van int (we zullen in 2038 jaar geen 32-bits integers meer hebben).
Ook tijdstempel-ontleding toegevoegd.
public static class DateTimeHelper
{
/// <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 long ToUnixTimestamp(this DateTime value)
{
return (long)(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 long UnixTimestamp(this DateTime ignored)
{
return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
}
/// <summary>
/// Returns a local DateTime based on provided unix timestamp
/// </summary>
/// <param name="timestamp">Unix/posix timestamp</param>
/// <returns>Local datetime</returns>
public static DateTime ParseUnixTimestamp(long timestamp)
{
return (new DateTime(1970, 1, 1)).AddSeconds(timestamp).ToLocalTime();
}
}
Antwoord 7
Als je 1970 aftrekt van de huidige tijd, houd er dan rekening mee dat de tijdspanne meestal een veld van niet nul milliseconden zal hebben. Als je om wat voor reden dan ook geïnteresseerd bent in milliseconden, houd hier dan rekening mee.
Dit is wat ik heb gedaan om dit probleem te omzeilen.
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.
Antwoord 8
Dit is wat ik gebruik.
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;
}
}
Antwoord 9
Hieronder staat een 2-weg extensieklasse die het volgende ondersteunt:
- Tijdzonelokalisatie
- Invoer\uitvoer in seconden of milliseconden.
In het geval van OP is het gebruik:
DateTime.Now.ToUnixtime();
of
DateTime.UtcNow.ToUnixtime();
Hoewel er een direct antwoord bestaat, geloof ik dat het beter is om een generieke aanpak te gebruiken.
Vooral omdat het zeer waarschijnlijk is dat een project dat een dergelijke conversie nodig heeft, deze extensies toch ook nodig heeft, dus het is beter om voor iedereen dezelfde tool te gebruiken.
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;
}
}
}
Antwoord 10
Deze oplossing heeft in mijn situatie geholpen:
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;
}
}
helper in code gebruiken:
double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)
Antwoord 11
Ik heb de meest elegante benaderingen van deze hulpprogramma-methode samengevoegd:
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;
}
Antwoord 12
Er is een ToUnixTimeMilliseconds voor DateTimeOffset in Systeem
Je kunt een vergelijkbare methode schrijven voor DateTime:
public static long ToUnixTimeSeconds(this DateTime value)
{
return value.Ticks / 10000000L - 62135596800L;
}
10000000L – teken omzetten in seconden
62135596800L – het omzetten van 01.01.01 naar 01.01.1978
Er is geen probleem met Utc en lekken
Antwoord 13
Ik heb dit gebruikt na een tijdje worstelen, het is ook geschikt voor de tijdzone-offset:
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;
}
Antwoord 14
Met .NET 6.0, longgebruiken om 2038te vermijden:
DateTime.UtcNownaar UnixTime:
long seconds = (long)DateTime.UtcNow.Subtract(DateTime.UnixEpoch).TotalSeconds;
UnixTime naar DateTime.UtcNow
DateTime timestamp = DateTime.UnixEpoch.AddSeconds(seconds);
Fiddle: https://dotnetfiddle.net/xNhO6q
Antwoord 15
De eenvoudige code die ik gebruik:
public static long CurrentTimestamp()
{
return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds * 1000);
}
Deze code geeft een unix-tijdstempel, in totaal milliseconden van 01/01/1970tot nu.