Java System.currentTimeMillis () équivalent en C #

Quel est l'équivalent de Java System.currentTimeMillis()en C #?

Une alternative:

private static readonly DateTime Jan1st1970 = new DateTime
    (1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

public static long CurrentTimeMillis()
{
    return (long) (DateTime.UtcNow - Jan1st1970).TotalMilliseconds;
}

Un idiome courant en Java consiste à utiliser le currentTimeMillis()à des fins de synchronisation ou de planification, où vous n'êtes pas intéressé par les millisecondes réelles depuis 1970, mais calculez plutôt une valeur relative et comparez les appels ultérieurs de currentTimeMillis()à cette valeur.

Si c'est ce que vous recherchez, l'équivalent C # est Environment.TickCount.

Si vous êtes intéressé par TIMING, ajoutez une référence à System.Diagnostics et utilisez un chronomètre.

Par exemple:

var sw = Stopwatch.StartNew();
...
var elapsedStage1 = sw.ElapsedMilliseconds;
...
var elapsedStage2 = sw.ElapsedMilliseconds;
...
sw.Stop();

DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()

le System.currentTimeMillis()in java renvoie l'heure actuelle en millisecondes à partir du 1/1/1970

c # ce serait

public static double GetCurrentMilli()
    {
        DateTime Jan1970 = new DateTime(1970, 1, 1, 0, 0,0,DateTimeKind.Utc);
        TimeSpan javaSpan = DateTime.UtcNow - Jan1970;
        return javaSpan.TotalMilliseconds;
    }

edit: faites-le utc comme suggéré :)

Nous pourrions également avoir un peu de fantaisie et le faire comme une méthode d'extension, de sorte qu'il se bloque hors de la classe DateTime:

public static class DateTimeExtensions
{
    private static DateTime Jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    public static long currentTimeMillis(this DateTime d)
    {
        return (long) ((DateTime.UtcNow - Jan1st1970).TotalMilliseconds);
    }
}

Voici un moyen simple de se rapprocher de l'horodatage Unix. L'utilisation de UTC est plus proche du concept unix, et vous devez convertir de doubleà long.

TimeSpan ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc));
long millis = (long)ts.TotalMilliseconds;
Console.WriteLine("millis={0}", millis);

imprime:

millis=1226674125796

Le framework n'inclut pas les anciennes secondes (ou millisecondes) depuis 1970. Le plus proche que vous obtenez est DateTime.Ticks qui est le nombre de 100 nanosecondes depuis le 1er janvier 0001.

Je considère simplement le moyen le plus simple de réaliser ce que vous recherchez comme suit:

DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond

Si vous voulez qu'un horodatage soit comparé entre différents processus, différents langages (Java, C, C #), sous GNU / Linux et Windows (Seven au moins):

C #:

private static long nanoTime() {
   long nano = 10000L * Stopwatch.GetTimestamp();
   nano /= TimeSpan.TicksPerMillisecond;
   nano *= 100L;
   return nano;
}

Java:

java.lang.System.nanoTime();

C GNU / Linux:

static int64_t hpms_nano() {
   struct timespec t;
   clock_gettime( CLOCK_MONOTONIC, &t );
   int64_t nano = t.tv_sec;
   nano *= 1000;
   nano *= 1000;
   nano *= 1000;
   nano += t.tv_nsec;
   return nano;
}

C Windows:

static int64_t hpms_nano() {
   static LARGE_INTEGER ticksPerSecond;
   if( ticksPerSecond.QuadPart == 0 ) {
      QueryPerformanceFrequency( &ticksPerSecond );
   }
   LARGE_INTEGER ticks;
   QueryPerformanceCounter( &ticks );
   uint64_t nano = ( 1000*1000*10UL * ticks.QuadPart ) / ticksPerSecond.QuadPart;
   nano *= 100UL;
   return nano;
}

Je sais que la question demande l' équivalent, mais puisque j'utilise ces 2 pour les mêmes tâches que je lance dans GetTickCount . Je suis peut-être nostalgique mais System.currentTimeMillis () et GetTickCount () sont les seuls que j'utilise pour obtenir des tiques.

[DllImport("kernel32.dll")]
static extern uint GetTickCount();

// call
uint ticks = GetTickCount();