Codice "Solo debug" che dovrebbe essere eseguito solo quando "attivato"

Vorrei aggiungere del codice C # "solo debug" che viene eseguito solo se la persona che esegue il debug lo richiede. In C ++, facevo qualcosa di simile al seguente:

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
 // ...
}

Non posso fare esattamente lo stesso in C # poiché non esiste una statica locale.

Domanda : qual è il modo migliore per eseguire questa operazione in C #?

1. Devo usare un campo statico di classe privata con direttive del preprocessore C # (#if/#endif DEBUG )?
2. Devo usare l'attributo condizionale (per contenere il codice) e quindi un campo statico di classe privata ( non circondato dalle direttive del preprocessore C ##if/#endif DEBUG ?).
3. Qualcos'altro?

Una variabile di istanza sarebbe probabilmente il modo per fare ciò che vuoi. Potresti renderlo statico per mantenere lo stesso valore per la vita del programma (o thread a seconda del tuo modello di memoria statica), o renderlo un'istanza ordinaria var per controllarlo sulla vita di un'istanza di un oggetto. Se quell'istanza è un singleton, si comporteranno allo stesso modo.

#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
 // ...
}

Per essere completi, i pragma (direttive del preprocessore) sono considerati un po 'un kludge da usare per controllare il flusso del programma. .NET ha una risposta incorporata per metà di questo problema, utilizzando l'attributo "Conditional".

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.
  }    
  // ...
}

Nessun pragma, molto più pulito. Lo svantaggio è che Conditional può essere applicato solo ai metodi, quindi dovrai gestire una variabile booleana che non fa nulla in una build di rilascio. Poiché la variabile esiste esclusivamente per essere commutata dall'host di esecuzione VS e in una build di rilascio il suo valore non ha importanza, è abbastanza innocuo.

Quello che stai cercando è

[ConditionalAttribute("DEBUG")]

attributo.

Se ad esempio scrivi un metodo come:

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

qualsiasi chiamata effettuata a questo metodo all'interno del proprio codice verrà eseguita solo in modalità di debug. Se crei il tuo progetto in modalità di rilascio, anche la chiamata a "MyLovelyDebugInfoMethod" verrà ignorata e scaricata dal tuo binario.

Oh, e ancora una cosa se stai cercando di determinare se il tuo codice è attualmente in fase di debug al momento dell'esecuzione, è anche possibile controllare se il processo corrente è agganciato da un JIT. Ma questo è tutto insieme un altro caso. Pubblica un commento se questo è ciò che stai cercando di fare.

Puoi provare questo se hai solo bisogno del codice da eseguire quando hai un debugger collegato al processo.

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

Penso che possa valere la pena ricordare che [ConditionalAttribute]è nello System.Diagnostics;spazio dei nomi. Sono inciampato un po 'quando ho ottenuto:

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

dopo averlo usato per la prima volta (pensavo che sarebbe stato in System).

Se vuoi sapere se si esegue il debug, ovunque nel programma. Usa questo.

Dichiara la variabile globale.

bool isDebug=false;

Crea una funzione per controllare la modalità di debug

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

Nel metodo initialize chiama la funzione

isDebugging();

Ora nell'intero programma. Puoi controllare il debug ed eseguire le operazioni. Spero che questo ti aiuti!