Comment obtenir le timestamp unix en C#

J'ai eu de regarder autour de stackoverflow, et même regardé quelques-unes des suggestions de questions et aucune ne semble répondre, comment obtenez-vous un timestamp unix en C#?

Double Possible de Comment puis-je convertir un timestamp Unix de type DateTime et vice-versa?

InformationsquelleAutor bizzehdee | 2013-07-13

c#timestamp unix-timestamp

524

Vous obtenez un timestamp unix en C# en utilisant le type DateTime.UtcNow et en soustrayant de la valeur epoc temps de 1970-01-01.

par exemple
```
Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
```
DateTime.UtcNow peut être remplacé par tout DateTime l'objet que vous voulez pour obtenir le timestamp unix de l'.
- Parlant au nom de @wdhough. "Cette réponse a limitation de la limite de Int32 qui est, je crois, de 2 147 483 647. Selon onlineconversion.com/unix_time.htm ce qui équivaut à un temps de mardi 19 janvier 2038 03:14:07 GMT je suppose que tout autre numéro de type, double, long, etc en fin de compte, la limite est trop, mais j'ai pensé qu'il vaut la peine de mentionner. Je choisis longtemps ici parce que je voulais un nombre entier. Espérons que cette aide"
- Le timestamp unix de l'est, traditionnellement, un entier de 32 bits, et dispose d'une gamme de '1970-01-01 00:00:01' UTC '2038-01-19 03:14:07' UTC.
- Fou que le temps UNIX conversion n'est pas dans le standard de la bibliothèque dans le cadre de DateTime.
- Ou à l'aide d'entiers arythmetic: DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).Ticks / TimeSpan.TicksPerSecond;
- La soustraction du datetime n'a pas besoin d'être UTC?
- DateTime ne se soucie pas de la zone de drapeau, et prend en compte uniquement les numéros lorsque vous effectuez des opérations mathématiques. DateTimeOffset est plus intelligent, et ne prennent en compte du fuseau horaire drapeau. C'est volontairement fait par .NET de l'équipe.
- Ne serait-ce pas une solution de secondes intercalaires?
- Le commentaire de @jjxtra semble correct pour moi et la réponse donnée ne fonctionne pas dans mon cas car DateTime(1970, 1, 1) est considéré comme l'heure locale par le .NET Framework (je suis en UTC+1 zone). Si le timestamp-je obtenir est en fait l'actuel Date UTC au moins le 1er janvier 1970 UTC+1 : j'ai une heure de saut. Ce que je comprends, à la fois la date doit être exprimé avec le même décalage UTC pour que ce code fonctionne correctement.
InformationsquelleAutor bizzehdee
420

Comme de .NET 4.6, il est DateTimeOffset.ToUnixTimeSeconds().

C'est une méthode d'instance, de sorte que vous devrait appeler une instance de DateTimeOffset. Vous pouvez également jeter un exemple de DateTime, si méfiez-vous du fuseau horaire.

Pour obtenir le timestamp actuel:
```
DateTimeOffset.UtcNow.ToUnixTimeSeconds()
```
Pour obtenir le timestamp à partir d'une DateTime:
```
DateTime foo = DateTime.UtcNow;
long unixTime = ((DateTimeOffset)foo).ToUnixTimeSeconds();
```
- Bon. Il est temps
- Jusqu'à ce que le Unix Millenium Bug hits 🙂
- Heureusement, il renvoie un Int64 - par le temps qui passe, de plus, nous aimerions ne pas être à l'aide de Terre ans de plus pour le manque de Terre.
- Pour quelqu'un d'autre vous demandez-vous, vous pouvez obtenir le timestamp actuel avec DateTimeOffset.Now.ToUnixTimeSeconds()
- Je l'aide .net de 4,6 aswell et trouvé poignée pour moi d'utiliser DateTime.Now.ToFileTimeUtc()
- De jeu de mots?
- n' pas retourner le même que DateTimeOffset.Now.ToUnixTimeSeconds(). Selon MSDN, “Un fichier Windows le temps est une valeur de 64 bits qui représente le nombre d'intervalles de 100 nanosecondes qui se sont écoulées depuis le 12:00 à minuit, le 1er janvier 1601 A. D. (C. E.) Temps Universel Coordonné (UTC).”
- Vous pouvez obtenir de l'UTC unixtimestamp avec: DateTimeOffset.UtcNow.ToUnixTimeSeconds()
- Cela devrait être la réponse. Up!
- c'est UNE réponse, mais pas LA réponse, comme tout le monde ne l'utilise 4.6 (ou est en mesure d'utiliser, pour quelque raison que ce soit)
- Oneline pour ceux qui veulent modifier la date en cours: DateTimeOffset.Now.AddDays(365).ToUnixTimeSeconds()
- Merci pour cette excellente réponse. Vous ne s'arrête pas à mentionner seulement la fonction, mais vous avez montré la procédure d'appel dans son intégralité. Ceci est extrêmement utile pour les gens comme moi qui ne savent pas comment toutes les classes.
InformationsquelleAutor Bob
37

Vous pouvez également utiliser les Tiques. Je suis codant pour Windows Mobile donc ne pas avoir le jeu complet de méthodes. TotalSeconds n'est pas disponible pour moi.
```
long epochTicks = new DateTime(1970, 1, 1).Ticks;
long unixTime = ((DateTime.UtcNow.Ticks - epochTicks) / TimeSpan.TicksPerSecond);
```
ou
```
TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
double unixTime = unixTicks.TotalSeconds;
```
- Erreur pour la deuxième solution: Impossible de convertir le type de source de "double", à la cible de type "long".
- unixTime devrait être un double
- Le deuxième échantillon est fixe
- new DateTime(1970, 1, 1) crée un temps de non précisée Kind de la propriété. Ce que vous voulez vraiment new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc) pour être vraiment correct
- Merci à vous, c'est le travail de 100%
InformationsquelleAutor Dave Hindle

C'est ce que j'utilise:

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

Gardez à l'esprit que cette méthode sera de retour le temps Universel Coordonné UTC (Temps).

InformationsquelleAutor Bartłomiej Mucha

19

Tronquer .TotalSeconds est important, car il est défini comme the value of the current System.TimeSpan structure expressed in whole fractional seconds.

Et comment agit d'une extension pour DateTime? Le second est probablement plus déroutant que ça vaut le coup jusqu'à ce que la propriété des extensions existent.
```
///<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);
}
```
- N'est-ce pas le cast en int le fait déjà?
- Méthode d'Extension est clairement le moyen de le faire proprement. C'est un excellent, mature réponse et je ne comprends pas pourquoi il a si peu de votes. Assez sûr que Robba est correcte - la coulée de la sortie (int) tronque automatiquement le résultat. (Littéralement en ignorant la partie décimale de la double).
- (ce DateTime ignoré) est très, très trompeuse
InformationsquelleAutor Brad
6

Lorsque vous soustrayez 1970 à partir de l'heure actuelle, sachez que la plage de temps sera le plus souvent n'est pas nulle millisecondes champ. Si pour quelque raison vous êtes intéressé dans les millisecondes, gardez cela à l'esprit.

Voici ce que j'ai fait pour obtenir autour de cette question.
```
 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.
```
InformationsquelleAutor Kelly Anderson

C'est ce que j'utilise.

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

peut-être une méthode d'extension de type DateTime

InformationsquelleAutor Matthew James Lewis

Cette solution a aidé dans ma situation:

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

à l'aide d'un helper dans le code:

double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)

InformationsquelleAutor Aslan Kystaubayev

J'ai spliced le plus élégant des approches de cette méthode utilitaire:

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

InformationsquelleAutor XDS

Vous devez vous connecter pour publier un commentaire.