[EDIT 2x] Eu acho que escrevi errado a minha pergunta original, então eu peguei abaixo e reescrevi exatamente o que eu estou tentando fazer, para futuros leitores. ]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[Novo, brilhante, pergunta clara com melhor redação]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Eu tenho um loop que está sendo executado para uma estrutura de simulação / jogo. Esse loop tem vários lugares onde é necessário determinar quanto tempo - na realidade - passou, para que a lógica nesses locais especiais - especificamente, renderização e atualização - funcione corretamente. Tem a opção de ser um Passo de Tempo Fixo (unfixed[update/render] é falso) ou não.

O problema surge quando a Depuração Baseada em Ponto de Interrupção é feita em qualquer ponto do aplicativo, pois usa um cronômetro para descobrir quanto tempo real passou (com a finalidade de a física e a animação se moverem a uma velocidade realista e não com base em quantas quadros que o computador pode produzir).

Parece (mais ou menos) assim, usandovários cronômetros para cada 'parte' do loop de aplicativo que precisa saber quanto tempo passou desde que a última parte ocorreu:

while ( RunningTheSimulation ) {
    /* ... Events and other fun awesome stuff */

    TimeSpan updatedifference = new TimeSpan( updatestopwatch.ElapsedTicks );

    if ( unfixedupdate || updatedifference > updateinterval ) {

        Time = new GameTime( updatedifference,
                                    new TimeSpan( gamestopwatch.ElapsedTicks ) );
        Update( Time );
        ++updatecount;
        updatestopwatch.Reset( );
        updatestopwatch.Start( );
    }

    TimeSpan renderdifference = new TimeSpan( renderstopwatch.ElapsedTicks );

    if ( unfixedrender || renderdifference > renderinterval ) {

        Time = new GameTime( renderdifference,
                                 new TimeSpan( gamestopwatch.ElapsedTicks ) );
        Render( Time );
        ++rendercount;
        renderstopwatch.Reset( );
        renderstopwatch.Start( );

    }
}   

Algumas informações sobre as variáveis:

updatestopwatch é umCronômetro pelo tempo gasto fora da função Update (),

renderstopwatch é umCronômetro pelo tempo gasto fora da função Render () e

gamestopwatch é umCronômetro pelo tempo total decorrido da simulação / jogo em si.

O problema surge quando eu depuro em qualquer lugar no aplicativo. Como os cronômetros estão medindo em tempo real, a simulação será completamente descartada por qualquer tipo de depuração baseada em ponto de interrupção, pois os cronômetros continuarão contando o tempo, depurando ou não o aplicativo. Eu não estou usando os cronômetros para medir o desempenho: estou usando-os para controlar o tempo entre re-ocorrências de atualização, renderização e outros eventos como os ilustrados acima. Isso fica extremamente frustrante quando eu quebro, analiso e corrijo um erro em Update (), mas então o tempo Render () é tão completamente desligado que qualquer exibição dos resultados da simulação é chutada de forma vingativa.

Dito isso, quando eu paro de depurar completamente, obviamente não é um problema, mas eu tenho muito trabalho de desenvolvimento para fazer e eu vou estar depurando por um longo tempo, então apenas fingir que isso não é inconveniente não funcionará infelizmente. = [

Eu olhei para os contadores de desempenho, mas não consigo entender como fazê-los funcionar no contexto do que estou tentando fazer: Render e Update podem conter qualquer quantidade de código arbitrário (eles são específicos para qualquer simulação que esteja sendo executada sobre essawhile loop), o que significa que não posso fazerPerformanceCounter.Increment() para os componentes individuais do loop.

Eu continuarei bisbilhotando System.Diagnostics e outros namespaces .NET, mas até agora eu criei espaços em branco apenas para "ignorar" o tempo gasto no Debugger anexado ...

Alguém tem alguma ideia ou insight?

[[EDITS 5x] Corrigimos erros de ortografia e garantimos que a formatação de tudo estivesse correta. Me desculpe por isso. ]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[Original, pergunta menos clara]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Eu tenho um loop constante em execução em um aplicativo c #, que eu depuro o tempo todo. Atualmente estou usando um cronômetro, mas eu poderia usar qualquer outro mecanismo para rastrear o tempo de passagem. Meu problema começa quando eu faço coisas como usar pontos de interrupção em algum lugar durante este loop (fechado em um típicowhile (true) { ... }:

if ( unfixedupdate || updatedifference > updateinterval ) 
{
    Time = new GameTime( updatedifference, 
                        new TimeSpan( gamestopwatch.ElapsedTicks ) );
    Update( Time );
    ++updatecount;
    updatestopwatch.Reset( );
    updatestopwatch.Start( );
}

O tempo mede-se bem, mas mede o tempo real real - incluindoqualquer tempo gasto depurando. O que significa que se eu estiver cutucando por 17 segundos depoisupdatestopwatch.Reset(), isso é composto no meu loop e - pelo menos uma repetição desse loop - eu tenho que lidar com o tempo extra que gastei em tempo real faturando em todos os meus cálculos.

Existe alguma maneira que eu possa ligar para o depurador para saber quando está congelando o aplicativo, para que eu possa contra-medir o tempo e subtrair-lo em conformidade? Como tagged, estou usando .NET e C # para isso, mas qualquer coisa relacionada ao Visual Studio também pode ajudar a me seguir na direção certa.

[EDITAR] Para fornecer mais informações, estou usando vários cronômetros (para atualização, renderização e alguns outros eventos em uma fila de mensagens diferente). Se eu definir um ponto de interrupção dentro de Update () ou em qualquer outra parte do aplicativo, os cronômetros medirão com precisão o tempo real gasto entre eles. Isso inclui o tempo gasto na depuração de vários componentes completamente não relacionados do meu aplicativo que são chamados downstream deUpdate() ouRender() ouInput() Obviamente, o Timing da simulação (controlado pelo parâmetro GameTime passado para as funções Atualizar, Renderizar etc.) não funcionará corretamente se, mesmo que a CPU demore apenas 13 ms para concluir a função de atualização, eu gasto13 segundos extras de depuração (olhando as variáveis ​​e depois Continue com a simulação); o problema é que eu vou ver os outros cronômetros de repente representando13 extra segundos de tempo. Se isso ainda não faz sentido, eu gritei novamente.