c# - how - Código "Debug only" que debería ejecutarse solo cuando está "encendido"

if release c#

Question

Me gustaría agregar un código C "solo de depuración" que solo se ejecuta si la persona encargada de la depuración lo solicita. En C ++, solía hacer algo similar a lo siguiente:

void foo()
{   
  // ...
#ifdef DEBUG
  static bool s_bDoDebugOnlyCode = false;
  if (s_bDoDebugOnlyCode)
  {
      // Debug only code here gets executed when the person debugging 
      // manually sets the bool above to true.  It then stays for the rest
      // of the session until they set it to false.
  }
#endif
 // ...
}

No puedo hacer exactamente lo mismo en C # ya que no hay estática local.

Pregunta : ¿Cuál es la mejor manera de lograr esto en C #?

1. ¿Debo usar un campo estático de clase privada con las directivas del preprocesador C # (# if / # endif DEBUG)?
2. ¿Debo usar el atributo Condicional (para mantener el código) y luego un campo estático de clase privada ( no rodeado por las directivas del preprocesador C # # if / # endif DEBUG?).
3. ¿Algo más?

Answer 1

Creo que vale la pena mencionar que [ConditionalAttribute] está en System.Diagnostics; espacio de nombres Me tropecé un poco cuando llegué:

Error 2 The type or namespace name ''ConditionalAttribute'' could not be found (are you missing a using directive or an assembly reference?)

después de usarlo por primera vez (pensé que habría estado en el System ).

Answer 2

Lo que estás buscando es

[ConditionalAttribute("DEBUG")]

atributo.

Si, por ejemplo, escribe un método como:

[ConditionalAttribute("DEBUG")]
public static void MyLovelyDebugInfoMethod(string message)
{
    Console.WriteLine("This message was brought to you by your debugger : ");
    Console.WriteLine(message);
}

cualquier llamada que realice a este método dentro de su propio código solo se ejecutará en modo de depuración. Si construye su proyecto en modo de lanzamiento, incluso la llamada al "MyLovelyDebugInfoMethod" será ignorada y descartada de su binario.

Ah, y una cosa más si está tratando de determinar si su código se está depurando actualmente en el momento de la ejecución, también es posible verificar si el proceso actual está enganchado por un JIT. Pero esto es todo junto otro caso. Publique un comentario si esto es lo que intenta hacer.

Answer 3

Puede intentar esto si solo necesita el código para ejecutar cuando tiene un depurador conectado al proceso.

if (Debugger.IsAttached)
{
     // do some stuff here
}

Answer 4

Si desea saber si la depuración, en cualquier lugar del programa. Utilizar esta.

Declarar variable global

bool isDebug=false;

Crear función para verificar el modo de depuración

[ConditionalAttribute("DEBUG")]
    public static void isDebugging()
    {
        isDebug = true;
    }

En el método de inicialización, llame a la función

isDebugging();

Ahora en todo el programa. Puede verificar la depuración y hacer las operaciones. ¡Espero que esto ayude!

Answer 5

Una variable de instancia probablemente sea la forma de hacer lo que desee. Puede hacer que sea estático para persistir el mismo valor durante la vida del programa (o hilo según su modelo de memoria estática) o convertirlo en una instancia ordinaria de var para controlarlo durante la vida de una instancia de objeto. Si esa instancia es un singleton, se comportarán de la misma manera.

#if DEBUG
private /*static*/ bool s_bDoDebugOnlyCode = false;
#endif

void foo()
{   
  // ...
#if DEBUG
  if (s_bDoDebugOnlyCode)
  {
      // Code here gets executed only when compiled with the DEBUG constant, 
      // and when the person debugging manually sets the bool above to true.  
      // It then stays for the rest of the session until they set it to false.
  }
#endif
 // ...
}

Para ser completo, los pragmas (directivas de preprocesador) se consideran un poco difíciles de usar para controlar el flujo del programa. .NET tiene una respuesta integrada para la mitad de este problema, utilizando el atributo "Condicional".

private /*static*/ bool doDebugOnlyCode = false; 
[Conditional("DEBUG")]
void foo()
{   
  // ...    
  if (doDebugOnlyCode)
  {
      // Code here gets executed only when compiled with the DEBUG constant, 
      // and when the person debugging manually sets the bool above to true.  
      // It then stays for the rest of the session until they set it to false.
  }    
  // ...
}

Sin pragmas, mucho más limpio. El inconveniente es que Conditional solo se puede aplicar a métodos, por lo que tendrá que lidiar con una variable booleana que no hace nada en una compilación de lanzamiento. Como la variable existe únicamente para ser conmutada desde el host de ejecución de VS, y en una versión de lanzamiento, su valor no importa, es bastante inofensivo.