Código “somente depuração” que deve ser executado apenas quando “ativado”

Eu gostaria de adicionar algum código C # "somente depuração" que só é executado se a pessoa que está depurando o solicitar. Em C ++, eu costumava fazer algo semelhante ao seguinte:

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

Não posso fazer exatamente o mesmo em C #, pois não há estática local.

Questão : Qual é a melhor maneira de fazer isso em C #?

1. Devo usar um campo estático de classe privada com diretivas de pré-processador C # ( #if/#endif DEBUG)?
2. Devo usar o atributo Conditional (para manter o código) e, em seguida, um campo estático de classe privada ( não cercado por diretivas de pré-processador C # #if/#endif DEBUG?).
3. Algo mais?

Uma variável de instância provavelmente seria a maneira de fazer o que você deseja. Você pode torná-lo estático para persistir o mesmo valor durante a vida do programa (ou thread, dependendo do seu modelo de memória estática), ou torná-lo uma instância var comum para controlá-lo durante a vida de uma instância de objeto. Se essa instância for um singleton, eles se comportarão da mesma maneira.

#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 completar, os pragmas (diretivas do pré-processador) são considerados um pouco complicados para usar para controlar o fluxo do programa. O .NET tem uma resposta incorporada para metade desse problema, usando o 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.
  }    
  // ...
}

Sem pragmas, muito mais limpo. A desvantagem é que Condicional só pode ser aplicado a métodos, então você terá que lidar com uma variável booleana que não faz nada em uma versão de lançamento. Como a variável existe apenas para ser alternada do host de execução do VS, e em uma versão de compilação seu valor não importa, é bastante inofensivo.

O que você está procurando é

[ConditionalAttribute("DEBUG")]

atributo.

Se você, por exemplo, escreve um 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);
}

qualquer chamada que você fizer a este método dentro de seu próprio código será executada apenas no modo de depuração. Se você construir seu projeto em modo de lançamento, até mesmo a chamada de "MyLovelyDebugInfoMethod" será ignorada e descartada de seu binário.

Ah, e mais uma coisa, se você está tentando determinar se o seu código está ou não sendo depurado no momento da execução, também é possível verificar se o processo atual está conectado por um JIT. Mas tudo isso junto é outro caso. Poste um comentário se é isso que você está tentando fazer.

Você pode tentar isso se só precisar que o código seja executado quando tiver um depurador anexado ao processo.

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

Acho que vale a pena mencionar que [ConditionalAttribute]está no System.Diagnostics;namespace. Eu tropecei um pouco quando cheguei:

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

depois de usá-lo pela primeira vez (pensei que teria sido System).

Se você quiser saber se está depurando, em todos os lugares do programa. Usa isto.

Declare a variável global.

bool isDebug=false;

Criar função para verificar o modo de depuração

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

No método de inicialização, chame a função

isDebugging();

Agora em todo o programa. Você pode verificar a depuração e fazer as operações. Espero que isto ajude!