Wie man den Unix-Zeitstempel in C# bekommt

Question

Ich habe mich auf Stack Overflow umgesehen und auch einige der vorgeschlagenen Fragen angeschaut, aber keine scheint zu beantworten, wie man einen Unix-Zeitstempel in C# bekommt.

Answer 1

Die Trunkierung von .TotalSeconds ist wichtig, da es definiert ist als der Wert der aktuellen System.TimeSpan-Struktur ausgedrückt in ganzen Bruchteilen von Sekunden.

Und wie wäre es mit einer Erweiterung für DateTime? Die zweite ist wahrscheinlich verwirrender als es wert ist, bis Eigenschaftserweiterungen existieren.

/// 
/// Konvertiert ein gegebenes DateTime in einen Unix-Zeitstempel
/// 
/// Jede DateTime
/// Der gegebene DateTime im Unix-Zeitstempelformat
public static int ToUnixTimestamp(this DateTime value)
{
    return (int)Math.Truncate((value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

/// 
/// Ruft einen Unix-Zeitstempel ab, der den aktuellen Moment repräsentiert
/// 
/// Parameter ignoriert
/// Jetzt als Unix-Zeitstempel ausgedrückt
public static int UnixTimestamp(this DateTime ignored)
{
    return (int)Math.Truncate((DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}

Answer 2

Aktualisierter Code von Brad mit einigen Änderungen: Sie benötigen kein Math.truncate, die Konvertierung in int oder long trägt automatisch den Wert ab. In meiner Version verwende ich long anstelle von int (Wir werden bis zum Jahr 2038 die 32-Bit-ganzen Zahlen überschreiten). Außerdem wurde die Zeitstempel-Analyse hinzugefügt.

public static class DateTimeHelper
{
    /// 
     /// Konvertiert ein gegebenes DateTime in einen Unix-Zeitstempel
     /// 
     /// Ein beliebiges DateTime
     /// Das gegebene DateTime im Unix-Zeitstempelformat
    public static long ToUnixTimestamp(this DateTime value)
    {
        return (long)(value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
    }

    /// 
    /// Gibt einen Unix-Zeitstempel für den aktuellen Moment zurück
    /// 
    /// Ignorierte Parameter
    /// Jetzt als Unix-Zeitstempel ausgedrückt
    public static long UnixTimestamp(this DateTime ignored)
    {
        return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
    }

    /// 
    /// Gibt ein lokales DateTime basierend auf dem angegebenen Unix-Zeitstempel zurück
    /// 
    /// Unix/POSIX-Zeitstempel
    /// Lokales Datum und Uhrzeit
    public static DateTime ParseUnixTimestamp(long timestamp)
    {
        return (new DateTime(1970, 1, 1)).AddSeconds(timestamp).ToLocalTime();
    }

}

Answer 3

Wenn Sie von der aktuellen Zeit 1970 abziehen, sollten Sie beachten, dass der Zeitraum in den meisten Fällen ein Millisekundenfeld ungleich null haben wird. Wenn Sie aus irgendeinem Grund an den Millisekunden interessiert sind, denken Sie daran.

Hier ist, was ich getan habe, um dieses Problem zu umgehen.

 DateTime now = UtcNow();

 // Millisekunden nicht enthalten.
 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)); // Bestanden.

Answer 4

Im Folgenden finden Sie eine 2-Wege-Erweiterungsklasse, die Folgendes unterstützt:

• Zeitzonenlokalisierung
• Eingabe\Ausgabe in Sekunden oder Millisekunden.

Im Falle des OP wird die Verwendung wie folgt sein:

DateTime.Now.ToUnixtime();

oder

DateTime.UtcNow.ToUnixtime();

Auch wenn eine direkte Antwort existiert, glaube ich, dass es besser ist, einen generischen Ansatz zu verwenden. Vor allem, weil es sehr wahrscheinlich ist, dass ein Projekt, das eine solche Konvertierung benötigt, auch diese Erweiterungen benötigt, ist es besser, für alles dasselbe Werkzeug zu verwenden.

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

        /// 
        /// Wandelt einen Unix-Zeitstempel (UTC-Zeitzone per Definition) in ein DateTime-Objekt um
        /// 
        /// Ein Eingabewert des Unix-Zeitstempels im Sekunden- oder Millisekundenformat
        /// Soll die Ausgabe lokalisiert werden oder in UTC-Zeitzone bleiben?
        /// Ist die Eingabe in Millisekunden oder Sekunden?
        /// 
        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;
        }

        /// 
        /// Wandelt ein DateTime-Objekt in einen Unix-Zeitstempel um
        /// 
        /// beliebiges DateTime-Objekt als Eingabe
        /// Soll die Ausgabe in Millisekunden oder Sekunden sein?
        /// 
        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;
            }
        }
    }

Answer 5

Das ist, was ich benutze.

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