Quelle est la différence entre Debug et Release dans Visual Studio?

Débogage possible de la version Visual Studio dans .NET

Quelle est la différence entre Debug et Release dans Visual Studio?

Le plus important est qu'en mode Débogage, il n'y a pas d'optimisation, alors qu'en mode Release, il y a des optimisations. Ceci est important car le compilateur est très avancé et peut faire des améliorations de bas niveau assez délicates de votre code. En conséquence, certaines lignes de votre code peuvent être laissées sans aucune instruction, ou certaines peuvent être mélangées. Le débogage étape par étape serait impossible. De plus, les variables locales sont souvent optimisées de manière mystérieuse, de sorte que les montres et les QuickWatches ne fonctionnent souvent pas parce que la variable est "optimisée". Et il existe également une multitude d'autres optimisations. Essayez parfois de déboguer du code .NET optimisé et vous verrez.

Une autre différence clé est que, pour cette raison, les paramètres de version par défaut ne se soucient pas de générer des informations détaillées sur les symboles de débogage. C'est le fichier .PDB que vous avez peut-être remarqué et il permet au débogueur de déterminer quelles instructions d'assemblage correspondent à quelle ligne de code, etc.

«Debug» et «Release» ne sont en fait que deux étiquettes pour toute une série de paramètres qui peuvent affecter votre construction et votre débogage.

En mode "Débogage", vous disposez généralement des éléments suivants:

• Fichiers de la base de données de débogage du programme, qui vous permettent de suivre de près l'exécution du programme dans la source pendant l'exécution.
• Toutes les optimisations sont désactivées, ce qui vous permet d'inspecter la valeur des variables et de suivre les fonctions qui auraient autrement pu être optimisées à distance ou en ligne
• Une définition de préprocesseur _DEBUG qui vous permet d'écrire du code qui agit différemment en mode débogage par rapport à la version, par exemple pour instrumenter les ASSERT qui ne doivent être utilisés que lors du débogage
• Liens vers des bibliothèques qui ont également été compilées avec des options de débogage activées, qui ne sont généralement pas déployées auprès de clients réels (pour des raisons de taille et de sécurité)

En mode "Release", les optimisations sont activées (bien que plusieurs options soient disponibles) et la définition du préprocesseur _DEBUG n'est pas définie. Habituellement, vous voudrez quand même générer les fichiers PDB, car il est très utile de pouvoir "déboguer" en mode version lorsque les choses sont plus rapides.

La plupart du temps, le débogage comprend de nombreuses informations supplémentaires utiles lors du débogage. En mode sortie, tout est coupé et échangé contre la performance.

Si vous parcourez les options de compilation du projet et que vous les comparez, vous verrez quelles sont les différences.

En supposant que la question concerne le code natif / C ++ (ce n'est pas tout à fait clair d'après le libellé):

Fondamentalement, dans Debug, toutes les optimisations de génération de code sont désactivées. Certaines bibliothèques (par exemple, STL ) utilisent par défaut une vérification d'erreur plus stricte (par exemple, les itérateurs de débogage). Plus d'informations de débogage sont générées (par exemple pour "Modifier et continuer"). D'autres éléments sont générés dans le code pour détecter les erreurs (les valeurs des variables locales sont définies sur un modèle non initialisé et le tas de débogage est utilisé).

De plus, apparemment, le mode de débogage crée beaucoup de threads supplémentaires pour aider au débogage. Ceux-ci restent actifs tout au long de la vie du processus, que vous attachez un débogueur ou non. Voir ma question connexe ici .

Cela vaut probablement la peine de mentionner le très évident, que les indicateurs de construction permettent une logique différente qui devrait être utilisée juste pour changer la journalisation et la messagerie "console", mais cela peut être abusé et changer radicalement non seulement les bas niveaux, mais la logique métier réelle.

Notez également que lors de l'utilisation de MFC par exemple, les projets de débogage sont liés à des versions DLL non redistribuables comme MFC90D.DLLwhile release builds lien avec les versions redistribuables telles que MFC90.DLL. Ceci est probablement similaire à d'autres frameworks.

Par conséquent, vous ne serez probablement pas en mesure d'exécuter des applications de débogage sur des machines non développées.

Je me suis également intéressé à cette question lorsque j'avais développé une application copiée à partir d'une configuration de build existante.

J'ai un développeur qui est intéressant à utiliser cette application en mode débogage, alors je me suis demandé ce qu'il faudrait pour faire cette configuration de construction qui existe avec un nom de ReleaseMyBuild copié à partir d'une configuration de version (et devrait donc avoir tous les paramètres destinés à publier des optimisations ) pour changer soudainement d'équipes et devenir une version de débogage malgré le nom de configuration de construction déroutant.

J'ai pensé que la configuration du projet n'était qu'un nom et un moyen pratique de sélectionner «toute une série de paramètres», mentionne Joris Timmermans. Je voulais connaître les détails de ces paramètres qui font qu'une configuration de construction nommée "FOO" fonctionne comme une version de version optimisée .

En voici un aperçu. J'ai créé un nouveau VCXPROJ à partir du modèle de projet vide de Visual Studio 2010. Je l'ai ensuite copié et modifié les deux, le premier pour conserver le contenu de débogage et le second le contenu de la version. Voici le diff centré sur les différences pertinentes ...

LIBÉRATION

<PropertyGroup>
    <WholeProgramOptimization>true</WholeProgramOptimization>

<ClCompile>
    <Optimization>MaxSpeed</Optimization>
    <FunctionLevelLinking>true</FunctionLevelLinking>
    <IntrinsicFunctions>true</IntrinsicFunctions>
<Link>
    <EnableCOMDATFolding>true</EnableCOMDATFolding>
    <OptimizeReferences>true</OptimizeReferences>

DÉBOGUER

<PropertyGroup>
    <UseDebugLibraries>true</UseDebugLibraries>`

<ClCompile>
    <Optimization>Disabled</Optimization>

Il est intéressant de noter que dans la section Lien, ils ont tous les deux GenerateDebugInformationdéfini la valeur true.

La différence évidente que vous pouvez voir est la taille du binaire. Une version Debug produit un binaire plus grand qu'une version Release.

Lors de la compilation dans Debug, la table des symboles est ajoutée à l'objet compilé du fichier de code, ce qui permet aux programmes de débogage de puiser dans ces binaires et d'accéder aux valeurs des objets et des variables.

Une autre différence observable est que, en mode Release, le binaire planterait simplement sur une erreur fatale en mode Debug, si vous commencez à déboguer l'application dans Visual Studio, vous pouvez vérifier la pile d'appels qui vous indique l'emplacement exact de l'instruction erronée .

Je ne sais pas quelles sont les différences exactes, car il n'y a en fait aucune information facilement disponible à ce sujet.

Mais la principale différence observée est que la version finale corrompt parfois le fichier DLL résultant et rend ainsi votre application, application Web inutilisable.

Malheureusement, vous devez mettre la version de débogage en production. Et oui, pour publier, vous devez utiliser le bon vieux FTP.