[[EDITAR 2x] Creo que redacté mal mi pregunta original, por lo que la he desplazado hacia abajo y reescribí exactamente lo que estoy tratando de hacer para futuros lectores. ]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[Nueva, brillante, clara pregunta con mejor redacción]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tengo un bucle que se está ejecutando para un marco de simulación / juego. Este bucle tiene varios lugares donde necesita determinar cuánto tiempo, en realidad, ha pasado, de modo que la lógica dentro de estos lugares especiales, específicamente, Procesamiento y Actualización, pueda funcionar correctamente. Tiene la opción de ser un Paso de Tiempo Fijo (unfixed[update/render] es falso) o no.

El problema surge cuando se realiza la depuración basada en punto de interrupción en cualquier punto de la aplicación, ya que usa un cronómetro para determinar cuánto tiempo real ha pasado (con el propósito de que la física y la animación se muevan a una velocidad realista, y no se basen en la cantidad de marcos de la computadora puede producir).

Se ve (aproximadamente) así, usandocronómetros múltiples para cada 'parte' del bucle de aplicación que necesita saber cuánto tiempo ha pasado desde que ocurrió la 'parte' por última vez:

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( );

    }
}   

Alguna información sobre las variables:

updatestopwatch es unCronógrafo por el tiempo pasado fuera de la función Update (),

renderstopwatch es unCronógrafo por el tiempo pasado fuera de la función Render (), y

gamestopwatch es unCronógrafo para el tiempo total transcurrido de la simulación / juego en sí.

El problema surge cuando depuro en cualquier parte de la aplicación. Debido a que los cronómetros se miden en tiempo real, la simulación se desechará por completo por cualquier tipo de depuración basada en punto de interrupción porque los cronómetros continuarán contando el tiempo, ya sea que esté o no depurando la aplicación. No estoy usando los cronómetros para medir el rendimiento: los estoy usando para hacer un seguimiento del tiempo entre las repeticiones de Actualización, Render y otros eventos como los ilustrados anteriormente. Esto se vuelve extremadamente frustrante cuando rompo y analizo y corrijo un error en Update (), pero luego el tiempo de Render () está tan completamente apagado que cualquier visualización de los resultados de la simulación se vengue en la cara.

Dicho esto, cuando dejo de depurar por completo, obviamente no es un problema, pero tengo mucho trabajo de desarrollo por hacer y voy a depurar por mucho tiempo, así que fingir que esto no es un inconveniente no funcionará. , Desafortunadamente. = [

Miré los Contadores de rendimiento, pero parece que no puedo entender cómo hacer que funcionen en el contexto de lo que estoy tratando de hacer: Renderizar y Actualizar puede contener cualquier cantidad de código arbitrario (son específicos a cualquier simulación que se esté ejecutando encima de estowhile bucle), lo que significa que no puedo hacer unaPerformanceCounter.Increment() Para los componentes individuales del bucle.

Seguiré hurgando en System.Diagnostics y otros espacios de nombres de .NET, pero hasta ahora he aparecido espacios en blanco sobre cómo "ignorar" el tiempo empleado en el Depurador adjunto ...

¿Alguien tiene alguna idea o idea?

[[EDITS 5x] Corrigió faltas de ortografía y se aseguró de que el formato de todo fuera correcto. Lo siento por eso. ]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[Pregunta original, menos clara]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tengo un bucle constante ejecutándose en una aplicación de C #, que depuro todo el tiempo. Actualmente estoy usando un Cronómetro, pero podría usar cualquier otro mecanismo para seguir el paso del tiempo. Mi problema comienza cuando hago cosas como usar puntos de interrupción en algún lugar durante este bucle (incluido en un típicowhile (true) { ... }:

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

El tiempo se mide bien, pero mide el tiempo real real, incluidoalguna El tiempo que pasé depurando. Lo que significa que si estoy hurgando por 17 segundos despuésupdatestopwatch.Reset(), esto se complica en mi bucle y, por lo menos durante 1 repetición de ese bucle, tengo que lidiar con el tiempo extra que dediqué en tiempo real a tener en cuenta todos mis cálculos.

¿Hay alguna forma de conectarme al depurador para saber cuándo se está congelando la aplicación, para poder medir el tiempo y restarlo en consecuencia? Según lo etiquetado, estoy usando .NET y C # para esto, pero todo lo relacionado con Visual Studio también podría ayudarme a avanzar en la dirección correcta.

[EDITAR] Para proporcionar más información, estoy usando varios cronómetros (para actualizar, renderizar y algunos otros eventos en una cola de mensajes diferente). Si configuro un punto de interrupción dentro de Actualización (), o en cualquier otra parte de la aplicación, los cronómetros medirán con precisión el Tiempo Real transcurrido entre estos. Esto incluye el tiempo que dedico a depurar varios componentes completamente no relacionados de mi aplicación que se denominan en sentido descendente deUpdate() oRender() oInput() Obviamente, la sincronización de la simulación (controlada por el parámetro GameTime pasado a las funciones de actualización, procesamiento, etc.) no funcionará correctamente si, incluso si la CPU solo tardó 13 ms en finalizar la función de actualización, invierto13 segundos extra de depuración (mirando las variables y luego continuar con la simulación); El problema es que veré los otros cronómetros de repente dando cuenta de13 extra segundos de tiempo. Si todavía no tiene sentido, volveré a sonar.