Good day for all
in the middle of my application
I have 2 sections code
I want one to be completed for debug and not for released moded
and the second in a reverse manner
how I do setup this in visual studio
currently I achieved this by keeping 2 copies
of my application one copy with code commented
for debug mode and the other copy with code
commented for released mofe
thank you.
You can use preprocessor directives like so:
#if DEBUG
Console.WriteLine("Compiles when debug is configured");
#endif
//...
#if(!DEBUG)
Console.WriteLine("Compiles otherwise");
#endif
I'm trying to debug a C# application, and I've defined some debug-only code within #if DEBUG/#endif blocks, and despite setting the build to Debug and double-checking the project properties and ensuring it's set to output to Debug and that the "Define DEBUG constant" checkbox is checked, my code isn't running. This is what I'm trying to do:
#if DEBUG
log.Add("Executing this section of code.");
#endif
and also
#if DEBUG
SkipToThisOtherMethod();
return;
#endif
It's blowing right past without running that code. What am I doing wrong??
I had this problem and seemed to resolve it by un-ticking the Define DEBUG Constant, saving the project, re-ticked it and saved the project again. Then Build and run and the #if DEBUG and #if !DEBUG sections went back to working normally.
I've been doing the following in my C# code:
#if DEBUG
//Debugger only code
#endif
But for some reason when I do the same in my C# console application (that is built as a Windows service in VS 2010) it doesn't seem to work and for both Release and Debug configurations it looks like DEBUG is not defined.
Do I need to set something for that preprocessor constant to work?
When using the 'Debug' configuration, you have to go to project's Properties -> Build
and tick the 'Define DEBUG constant' box.
Either that, or define the conditional compilation symbol: DEBUG. As you can do with any other custom compilation symbol :)
I have the following code:
#if (DEBUG)
imgPath = GetDirectoryName(Application.ExecutablePath);
#else
imgPath = GetDirectoryName(Application.ExecutablePath) + "\\images\\";
#endif
When the code went into Production (live site) , it still looked the the DEBUG version. How is this possible? Is there something during the promotion process that can indicate do RELEASE vs DEBUG
You might have deployed a version with binaries taken from a Debug build configuration or in any case, the DEBUG variable set to True.
You need to build in RELEASE and use that output as the release candidate.
When using #if statements, it is checking to determine if the constant is defined. Under the project's properties->Build section, the DEBUG constant is (by default) set to be defined when in debug mode. There is no RELEASE constant unless you define it yourself. You may have used your build from debug mode or had the "Define DEBUG constant" checked for your release build. Double check which you used and your build settings.
Also, your code should be greyed out to indicate that VS will not be compiling that code. So if the code you wish to be using is grey, that is an indicator you have DEBUG defined somewhere.
In all the examples I've seen of the #if compiler directive, they use "DEBUG". Can I use "RELEASE" in the same way to exclude code that I don't want to run when compiled in debug mode? The code I want to surround with this block sends out a bunch of emails, and I don't want to accidentally send those out when testing.
RELEASE is not defined, but you can use
#if (!DEBUG)
...
#endif
No, it won't, unless you do some work.
The important part here is what DEBUG really is, and it's a kind of constant defined that the compiler can check against.
If you check the project properties, under the Build tab, you'll find three things:
A text box labelled "Conditional compilation symbols"
A check box labelled "Define DEBUG constant"
A check box labelled "Define TRACE constant"
There is no such checkbox, nor constant/symbol pre-defined that has the name RELEASE.
However, you can easily add that name to the text box labelled Conditional compilation symbols, but make sure you set the project configuration to Release-mode before doing so, as these settings are per configuration.
So basically, unless you add that to the text box, #if RELEASE won't produce any code under any configuration.
Nope.
While in debug configuration there is a DEBUG defined constant (automatically defined by Visual Studio) while there is no such constant defined for release mode. Check your project settings under build.
Selecting [Define DEBUG constant] under Project -> Build is like including #define DEBUG at the beginning of every file.
If you want to define a RELEASE constant for the release configuration go to:
Project Properties -> Build
Select Release Mode
in the Conditional compilation symbols textbox enter: RELEASE
On my VS install (VS 2008) #if RELEASE does not work. However you could just use #if !DEBUG
Example:
#if !DEBUG
SendTediousEmail()
#endif
I've never seen that before...but I have seen:
#if (DEBUG == FALSE)
and
#if (!DEBUG)
That work for ya?
You can use #if(!DEBUG) for this purposes.
"Pop Catalin" got it right. Controlling the definition based on the type of build provides a great deal of flexibility. For example, you can have a "DEBUG", "DEMO", and "RELEASE" configuration all in the same solution. That prevents the need for duplicate programming with two different solutions.
So yes #if RELEASE or #if (RELEASE) works the same as #if DEBUG when the RELEASE Conditional compilation symbol is defined.
The following is taken from "Pop Catalin" post:
If you want to define a RELEASE constant for the release configuration go to:
* Project Properties -> Build
* Select Release Mode
* in the Conditional compilation symbols textbox enter: RELEASE
I know this is an old question, but it might be worth mentioning that you can create your own configurations outside of DEBUG and RELEASE, such as TEST or UAT.
If then on the Build tab of the project properties page you then set the "Conditional compilation symbols" to TEST (for instance) you can then use a construct such as
#if (DEBUG || TEST )
//Code that will not be executed in RELEASE or UAT
#endif
You can use this construct for specific reason such as different clients if you have the need, or even entire Web Methods for instance. We have also used this in the past where some commands have caused issues on specific hardware, so we have a configuration for an app when deployed to hardware X.
You can create you own conditional compile-time symbols (any name you like).
Go to the "project Build dialog", located in the project properties box,
menu option: Project->[projectname] Properties...
You can also define them "at the top of the C# code file". Like:
#define RELEASE
// or
#undef RELEASE
you can use the symbol in a #if statement:
#if RELEASE
// code ...
#elif …
// code ...
#endif
// or
#if !RELEASE
// code ...
#endif
Whilst M4N's answer (#if (!DEBUG)) makes most sense, another option could be to use the preprocessor to amend other flag's values; e.g.
bool isRelease = true;
#if DEBUG
isRelease = false;
#endif
Or better, rather than referring to whether we're in release or debug mode, use flags that define the expected behavior and set them based on the mode:
bool sendEmails = true;
#if DEBUG
sendEmails = false;
#endif
This is different to using preprocessor flags, in that the flags are still there in production, so you incur the overhead of if (sendEmails) {/* send mails */} each time that code's called, rather than the code existing in release but not existing in debug, but this can be advantageous; e.g. in your tests you may want to call your SendEmails() method but on a mock, whilst running in debug to get additional output.
Another option:
#If CONFIG = "Release" Then
....
#End If
why not just
#if RELEASE
#undef DEBUG
#endif