C # DateTime.Now precision

Acabei de ter um comportamento inesperado com DateTime.UtcNow ao fazer alguns testes de unidade. Parece que quando você chama DateTime.Now/UtcNow em rápida sucessão, parece devolver o mesmo valor por um intervalo de tempo mais longo do que o esperado, em vez de capturar incrementos de milissegundos mais precisos.

Eu sei que existe uma classe de Cronômetro que seria mais adequada para fazer medições de tempo precisas, mas estava curioso para saber se alguém poderia explicar esse comportamento em DateTime. Existe uma precisão oficial documentada para DateTime.Now (por exemplo, com precisão de 50 ms?)? Por que DateTime.Now seria menos preciso do que a maioria dos clocks da CPU poderia suportar? Talvez seja apenas projetado para o menor denominador comum da CPU?

public static void Main(string[] args)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    for (int i=0; i<1000; i++)
    {
        var now = DateTime.Now;
        Console.WriteLine(string.Format(
            "Ticks: {0}\tMilliseconds: {1}", now.Ticks, now.Millisecond));
    }

    stopwatch.Stop();
    Console.WriteLine("Stopwatch.ElapsedMilliseconds: {0}",
        stopwatch.ElapsedMilliseconds);

    Console.ReadLine();
}

Por que DateTime.Now seria menos preciso do que a maioria dos clocks da CPU poderia suportar?

Um bom relógio deve ser preciso e exato ; esses são diferentes. Como diz a velha piada, um relógio parado é exatamente preciso duas vezes por dia, um relógio com um minuto de atraso nunca é preciso em nenhum momento. Mas o relógio um minuto atrasado é sempre preciso para o minuto mais próximo, ao passo que um relógio parado não tem nenhuma precisão útil.

Por que DateTime deveria ser preciso , digamos um microssegundo, quando não é possível que ele seja preciso em microssegundos? A maioria das pessoas não possui nenhuma fonte de sinais de hora oficiais com precisão de microssegundos. Portanto, dar seis dígitos após a casa decimal de precisão , dos quais os últimos cinco são lixo, seria mentir .

Lembre-se de que o objetivo de DateTime é representar uma data e hora . Timing de alta precisão não é o propósito de DateTime; como você observa, esse é o propósito do StopWatch. O objetivo de DateTime é representar uma data e hora para fins como exibir a hora atual para o usuário, calcular o número de dias até a próxima terça-feira e assim por diante.

Em suma, "que horas são?" e "quanto tempo isso demorou?" são questões completamente diferentes; não use uma ferramenta projetada para responder a uma pergunta para responder a outra.

Obrigado pela pergunta; este será um bom artigo de blog! :-)

A precisão do DateTime é um tanto específica do sistema em que está sendo executado. A precisão está relacionada à velocidade de uma troca de contexto, que tende a ser em torno de 15 ou 16 ms. (No meu sistema, demora cerca de 14 ms do meu teste, mas eu vi alguns laptops com uma precisão de 35-40 ms.)

Peter Bromberg escreveu um artigo sobre temporização de código de alta precisão em C #, que discute isso.

Eu gostaria de um Datetime preciso.Agora :), então preparei isso:

public class PreciseDatetime
{
    // using DateTime.Now resulted in many many log events with the same timestamp.
    // use static variables in case there are many instances of this class in use in the same program
    // (that way they will all be in sync)
    private static readonly Stopwatch myStopwatch = new Stopwatch();
    private static System.DateTime myStopwatchStartTime;

    static PreciseDatetime()
    {
        Reset();

        try
        {
            // In case the system clock gets updated
            SystemEvents.TimeChanged += SystemEvents_TimeChanged;
        }
        catch (Exception)
        {                
        }
    }

    static void SystemEvents_TimeChanged(object sender, EventArgs e)
    {
        Reset();
    }

    // SystemEvents.TimeChanged can be slow to fire (3 secs), so allow forcing of reset
    static public void Reset()
    {
        myStopwatchStartTime = System.DateTime.Now;
        myStopwatch.Restart();
    }

    public System.DateTime Now { get { return myStopwatchStartTime.Add(myStopwatch.Elapsed); } }
}

No MSDN você descobrirá que DateTime.Nowtem uma resolução aproximada de 10 milissegundos em todos os sistemas operacionais NT.

A precisão real depende do hardware. Melhor precisão pode ser obtida usando QueryPerformanceCounter.

Pelo que vale a pena, sem realmente verificar o código-fonte .NET, Eric Lippert forneceu um comentário sobre esta questão do SO dizendo que DateTime tem precisão de aproximadamente 30 ms. O raciocínio para não ter precisão de nanossegundos, em suas palavras, é que "não precisa ser".

Da documentação do MSDN :

A resolução desta propriedade depende do cronômetro do sistema.

Eles também afirmam que a resolução aproximada no Windows NT 3.5 e posterior é de 10 ms :)

A resolução dessa propriedade depende do cronômetro do sistema, que depende do sistema operacional subjacente. Tende a estar entre 0,5 e 15 milissegundos.

Como resultado, chamadas repetidas para a propriedade Now em um curto intervalo de tempo, como em um loop, podem retornar o mesmo valor.

Link MSDN