Code «Débogage uniquement» qui ne doit être exécuté que lorsque «activé»

Je voudrais append du code “debug only” de C # qui ne fonctionne que si le débogage le demande. En C ++, je faisais quelque chose de similaire à ce qui suit:

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

Je ne peux pas faire exactement la même chose en C # car il n’y a pas de statique locale.

Question : Quelle est la meilleure façon d’y parvenir en C #?

  1. Dois-je utiliser un champ statique de classe privée avec les directives de préprocesseur C # (# if / # endif DEBUG)?
  2. Dois-je utiliser l’atsortingbut Conditional (pour contenir le code), puis un champ statique de classe privée ( non entouré des directives de préprocesseur C # # if / # endif DEBUG?).
  3. Autre chose?

Une variable d’instance serait probablement la façon de faire ce que vous voulez. Vous pouvez le rendre statique pour conserver la même valeur pour la durée de vie du programme (ou du thread en fonction de votre modèle de mémoire statique), ou en faire une variable d’instance ordinaire pour la contrôler sur la durée de vie d’une instance d’object. Si cette instance est un singleton, ils se comporteront de la même manière.

 #if DEBUG private /*static*/ bool s_bDoDebugOnlyCode = false; #endif void foo() { // ... #if DEBUG if (s_bDoDebugOnlyCode) { // Code here gets executed only when comstackd 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 // ... } 

Juste pour être complet, les pragmas (directives de préprocesseur) sont considérés comme un peu compliqué à utiliser pour contrôler le déroulement du programme. .NET a une réponse intégrée pour la moitié de ce problème, en utilisant l’atsortingbut “Conditionnel”.

 private /*static*/ bool doDebugOnlyCode = false; [Conditional("DEBUG")] void foo() { // ... if (doDebugOnlyCode) { // Code here gets executed only when comstackd 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. } // ... } 

Pas de pragmas, beaucoup plus propre. L’inconvénient est que Conditional ne peut être appliqué qu’aux méthodes, vous devrez donc gérer une variable booléenne qui ne fait rien dans une version release. Comme la variable existe uniquement pour être basculée depuis l’hôte d’exécution VS, et que dans une version, sa valeur importe peu, c’est plutôt inoffensif.

Ce que vous cherchez est

 [ConditionalAtsortingbute("DEBUG")] 

atsortingbut.

Si vous écrivez par exemple une méthode comme:

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

tout appel que vous faites à cette méthode dans votre propre code ne sera exécuté qu’en mode débogage. Si vous construisez votre projet en mode release, même l’appel à la méthode MyLovelyDebugInfoMethod sera ignoré et vidé de votre fichier binary.

Et encore une chose, si vous essayez de déterminer si votre code est actuellement en cours de débogage au moment de l’exécution, il est également possible de vérifier si le processus en cours est lié à un JIT. Mais tout cela est un autre cas. Postez un commentaire si c’est ce que vous essayez de faire.

Vous pouvez essayer ceci si vous avez seulement besoin du code pour exécuter un débogueur associé au processus.

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

Si vous voulez savoir si le débogage, partout dans le programme. Utilisez ceci.

Déclarez la variable globale.

 bool isDebug=false; 

Créer une fonction pour vérifier le mode de débogage

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

Dans la méthode d’initialisation, appelez la fonction

 isDebugging(); 

Maintenant dans tout le programme. Vous pouvez vérifier le débogage et effectuer les opérations. J’espère que cela t’aides!

Je pense qu’il peut être utile de mentionner que [ConditionalAtsortingbute] est dans le System.Diagnostics; espace de noms. J’ai trébuché un peu quand j’ai eu:

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

après l’avoir utilisé pour la première fois (je pensais que cela aurait été dans le System ).