This question already has answers here:
#if (DEBUG) VS System.Diagnostics.Debugger.IsAttached
(6 answers)
Closed 7 years ago.
Is #if DEBUG executed when the program is debugged after it has been released (for example by debugger tools like OllyDBG) or is it already nuked by the compiler on release build?
Means whatever I do with #if DEBUG is visible after the program has been created on release build?
#if DEBUG is processed during compilation. The code inside is not compiled if the DEBUG symbol is not defined, so it cannot be executed in a release build.
From MSDN:
When the C# compiler encounters an #if directive, followed eventually by an #endif directive, it will compile the code between the directives only if the specified symbol is defined.
To my understanding, compiler directives like #if DEBUG are resolved at compile time, depending on the set symbols. In practice this means that the build configuration is taken into consideration. If DEBUG is not set during build, attaching a debugger later cannot make the removed part of the implementation magically reappear; the corresponding parts are indeed 'nuked' during compilation.
It's a pre-processor directive, so the code within the #if is compiled only if DEBUG symbol exists.
Thus, you won't be able to debug a code that it's not part of compiled intermediate language code...
#if DEBUG has nothing to do with Debugging but simply includes or excludes a part of source code in a build/assembly.
The standard Release Build settings do not define DEBUG so any code inside a #if DEBUG will not be part of a Release Build
Related
Is it possible to run specific code only when I am debugging the program via the debugging tools of Visual Studio?
If I use #if DEBUG or Conditional(“DEBUG”) the code is still triggered when running the .exe in the /Debug directory.
The #if DEBUG is for Conditional Compilation, it does not affect execution at runtime.
Instead use Debugger.IsAttached to branch at runtime.
Just to make it clear, the statements beginning with a hashtag are pre-processor directives. These directives are not present in the Translation Unit; thus these conditional statements do not exist in the compiled file.
EDIT It seems that this whole translation unit thing doesn't apply for C#
To Log output I am using the following code.
System.Diagnostics.Debug.WriteLine("Hello");
Now, its always advisory to remove such logs before the app is submitted.
So, is that we have to remove such lines, before we submit it for release or its done implicitly.
Is there any another better way to log output in C#, which removes the logging to the console when its released. I see Log4Net is one of them.
All methods on the System.Diagnostics.Debug class have the ConditionalAttribute, so under most compilers they will not be compiled into a Release build (unless you define the DEBUG attribute in the release build). 1
This is certainly true for the compilers within Visual Studio.
Your second question about log4Net is actually the reverse, and something to be careful about if you do decide to start using log4Net - log4Net debug calls are included within debug builds and are emitted if you have the logger set to the debug trace level (usually done with runtime configuration).
1. The MSDN pages are actually (IMO) a little bit unclear, but these SO posts agree with my interpretation:
System.Diagnostics.Debug.WriteLine in production code
C# Do Debug statements get compiled out when running in Release mode?
You can use preprocessor directive:
#if DEBUG
System.Diagnostics.Debug.WriteLine("Hello");
#endif
That line will be skipped when you'll build your application in Release build configuration.
I have the following code (inherited from a contractor):
public partial class StoredProcedures
{
#if NO_THREAD
readonly static String version = "XXXX, Version 1.02, Apr/29/2010";
#else
readonly static String version = "XXXX, Version 0.93, Dec/21/2006";
#endif
I can't seem to find NO_THREAD anywhere else. This is code that compiles and installs as a SQL assembly. Is it something special or am I missing something simple?
Try to check Project Properties->Build->General->Conditional compilation symbols for all Build configurations which you have for the project, It may be there.
Look for a #define statement. See the docs for #if preprocessor conditionals : http://msdn.microsoft.com/en-us/library/4y6tbswk.aspx
If you can't find a
define #NO_THREAD
Anywhere in the code, then it's probably because the contractor was defining the symbol by passing the /define compiler option.
See here for more details (typing from a cell, sorry for the format):
http://msdn.microsoft.com/en-us/library/0feaad6z.aspx
you should probably have a look at the c# pre-processor directives
No_Thread here is a symbol which can be defined by using #define No_Thread and when #define No_Thread is present then #if NO_THREAD will result in true and at compile time readonly static String version = "XXXX, Version 1.02, Apr/29/2010"; this statement will be compiled otherwise the next statement will be compiled.
this is generally used to differentiate between debug and release versions. have you noticed there are 2 versions in VS when you create a new project. if you write something like this somewhere in you code
#if DEBUG
Console.WriteLine("DEBUG VERSION");
#endif
then the string "DEBUG VERSION" would only be printed on the console when the project is in debug mode because the VS inserts a symbol DEBUG if you manually do it using the #define pre-processor then too this line would be compiled
NO_THREAD is a symbol for conditional compilation.
It can come from, #define NO_THREAD, from the project file, or from the nant file (or whatever method you use for building).
If it's defined, the first line of code is counted as part of the C# code. If it isn't, then the second is.
If that's the sole occurence, I'd say it was a hangover from something removed, but if you're uesd to using visual studio to build, then make sure there isn't a build file for nant in case the previous developer used that instead.
This is a conditional compilation symbol. In Visual Studio 2010, these appear on the Build page of your Project Properties in the Conditional compilation symbols text box. Probably one of your Configuration Manager configurations either contains this symbol or has at some point in the past. Presumably, there is another #if somewhere that disables a block of code that uses multiple threads if the NO_THREAD symbol is present.
I want to throw exceptions while debugging but in release mode I don't want to throw them. I am logging them into EventLog. This is the source of my problem but if I'm not wrong in C and Delphi there are some directives to make this.
In C# is there any way(directives or something else) which can ignore the lines in debug mode or release mode?
You can do it like this:
#if DEBUG
Console.WriteLine("Debug version");
#endif
http://msdn.microsoft.com/en-us/library/4y6tbswk.aspx
For your purposes (logging), you might also be interested in the ConditionalAttribute. It lets you mark an entire method as "remove all calls to this method in release builds".
If you do your logging in a lot of different places in your code, this would be much simpler than adding #if DEBUG around every single call site.
Use the #if DEBUG directive (and end with #endif). The DEBUG constant is defined when you run your application in debug mode (the Define DEBUG constant should be checked under the Build tab of your project properties).
#if(DEBUG)
......Code......
#else
......Code......
#endif
I have some code like this. If my application is running in Debug mode it should execute the #if(DEBUG) part, if it is running in Release mode it should execute the #else part. However, it is only executing the #if(DEBUG) part no matter which mode it is running in.
Am using WPF application with VS2010
Can anyone help me?
For Debug Configuration, your project settings should look like
For Release they should look like this
Can you verify that this is the case, and let us know if it is?
If not, what is there for each configuration?
Create a new project using all the default settings and check that you can make that work as expected. If so, your problem project must be "corrupted" in some way, perhaps by defining the DEBUG constant in the release configuration, or by having the debug project configuration selected for the release solution configuration.
It depends on how you create your configurations. For example if you create your configuration and use debug or release as a template DEBUG or RELEASE will be copied to the defined constraints element. It will not change the defined constraints element (in the project file) to the new configuration name.
Open up the project file and look for the configuration sections. Make sure the Platform, the below example it is "PROD" has an entry in the DefineConstants element. If it does the pre-compiler directives will don't work as expected in the code.
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'PROD|x86'">
<DefineConstants>PROD;TRACE</DefineConstants>
<OutputPath>bin\x86\PROD\</OutputPath>
</PropertyGroup>
Why are you putting DEBUG between parentheses?
#if DEBUG
Code
#else
Code
#endif
I would guess that in your project properties, under Build you have checked off Define DEBUG constant.
Try setting configuration mode to Release and run your application again. Default for Release is that the DEBUG constant is not defined, if you haven't tampered with if of course ;)
If Define DEBUG constant is not checked, that means you have a #define DEBUG lurking somewhere.
So two things to do. Check constant in options under Release mode, and check for any manually defined constant. It should be one of those.