Java System.currentTimeMillis () equivalente em C #

Qual é o equivalente do Java System.currentTimeMillis()em C #?

Uma alternativa:

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

Um idioma comum em Java é usar o currentTimeMillis()para fins de tempo ou programação, onde você não está interessado nos milissegundos reais desde 1970, mas em vez disso, calcule algum valor relativo e compare as chamadas posteriores currentTimeMillis()desse valor.

Se é isso que você está procurando, o equivalente em C # é Environment.TickCount.

Se você estiver interessado em TIMING, adicione uma referência a System.Diagnostics e use um cronômetro.

Por exemplo:

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

DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()

o System.currentTimeMillis()em java retorna a hora atual em milissegundos de 01/01/1970

c # isso seria

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

editar: tornou utc conforme sugerido :)

Também poderíamos ser um pouco mais elaborados e fazer isso como um método de extensão, de modo que fique fora da 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);
    }
}

Aqui está uma maneira simples de aproximar o carimbo de data / hora Unix. Usar o UTC está mais próximo do conceito unix e você precisa converter de doublepara 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);

estampas:

millis=1226674125796

A estrutura não inclui os segundos antigos (ou milissegundos) desde 1970. O mais próximo que você obtém é DateTime.Ticks, que é o número de 100 nanossegundos desde 1º de janeiro de 0001.

Eu apenas considero a maneira mais direta de alcançar o que você tem se esforçado da seguinte maneira:

DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond

Se você deseja que um carimbo de data / hora seja comparado entre diferentes processos, diferentes linguagens (Java, C, C #), sob GNU / Linux e Windows (sete pelo menos):

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

Eu sei que a pergunta pede equivalente, mas como eu uso esses 2 para as mesmas tarefas, coloco GetTickCount . Posso ser nostálgico, mas System.currentTimeMillis () e GetTickCount () são os únicos que uso para obter carrapatos.

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

// call
uint ticks = GetTickCount();