It seems like it would be ideal (in terms of readability) to use say Debug.WriteLine to write to output rather than a ton of #if DEBUG statements.
When the program is compiled in release mode, does all the overhead with the Debug.WriteLine go away as if it did not exist, or is the function still called, but nothing done internally?
If so, is there any way to obtain this functionality on a custom class, i.e., a static call would only be compiled in if we are in Debug mode?
It is called ConditionalAttribute and it is already there: Debug.WriteLine() calls are removed entirely when you compile in Release mode.
It is declared like this:
[ConditionalAttribute("DEBUG")]
public static void WriteLine(string message)
So any calls to it are removed if the DEBUG symbol is not declared, e.g., in the default configuration of a release build. (You can change what pre-processor symbols are defined for different build configurations in the project properties.)
The same is true for (almost?) every method in Debug. In fact, it is the main difference between Debug and Trace - Trace's methods stay in release also.
Related
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.
Take the following example:
public void Foo()
{
//Code...
Debug.Assert(ExpensiveTest());
//Code...
}
What happens to the the Debug.Assert method when I compile in release mode? Would ExpensiveTest() still run? If not, then how does it work (since it is not a macro that can be set to evaluate to nothing)? If it does run, then doesn't that defeat the purpose of debug assertions?
What happens to the the Debug.Assert method when I compile in release mode?
It's completely removed (including the call to ExpensiveTest), assuming you don't have the DEBUG conditional compilation symbol defined in your release configuration.
If you look at the documentation, the declaration uses [ConditionalAttribute("DEBUG")]:
[ConditionalAttribute("DEBUG")]
public static void Assert(
bool condition
)
ConditionalAttribute is used for conditional compilation. See Bart de Smet's blog post on conditional compilation for more details, along with section 17.4.2 of the C# 4 specification.
Assertions in Managed Code - MSDN
In Visual Basic and Visual C#, you can use the Assert method from
either Debug or Trace, which are in the System.Diagnostics namespace.
Debug class methods are not included in a Release version of your program, so they do not increase the size or reduce the speed of
your release code.
Also from the same link:
Note that calls to the Debug.Assert method disappear when you create
a Release version of your code. That means that the call that checks
the balance disappears in the Release version. To solve this problem,
you should replace Debug.Assert with Trace.Assert, which does not
disappear in the Release version
According to Debug.Assert Method (Boolean) Debug methods are compiled only in debug builds.
So, it you build correct release build (see menu item Debug/Configuration Manager for details) this method call will be removed.
Q. In C#, is a Debug.Assert test run in release mode?
The answer is "No." From Microsoft support: How to trace and debug in Visual C#:
You can use the Trace and the Debug classes separately or
together in the same application. In a Debug Solution Configuration
project, both Trace and Debug output are active. The project
generates output from both of these classes to all Listener
objects. However, a Release Solution Configuration project only
generates output from a Trace class. The Release Solution
Configuration project ignores any Debug class method invocations.
In particular, the last sentence makes it clear that Debug.Assert() statements (as well as other Debug class method invocations) are ignored in a Release build.
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).
I have a component which can be referenced in some projects (for example, Component.dll). I publish it, of course, in release mode.
In another project (for example, Project.exe) I reference Component.dll.
If I build Project.exe in Debug mode, is there a way to find out about that in my Component.dll library?
To clarify more: if I have a class and a method named Test within Component.dll. Can I do something like:
public void Test(){
if(Debug.IsInDebugMode)
...
}
Keep in mind that Component.dll is built in release mode.
Whether your code is built in Release or Debug mode doesn't matter a great deal. The generated IL is very nearly the same. The Debug version will have an attribute that the jitter uses to set compilation defaults, that attribute is missing in yours. The next thing that matters is exactly how you debug or run your application. The setting that's important is Tools + Options, Debugging, General, "Suppress JIT optimization on module load". It is ticked by default.
Which now makes it matter whether your app gets started by a debugger or not. That's easy to find out, use the System.Diagnostics.Debugger.IsAttached property. When false, the machine code generated from your IL is going to be optimized by the jitter. A degenerate case is attaching a debugger after the code got started. Kinda important that this doesn't make any difference to you btw.
I've been doing some performance testing around the use of System.Diagnostics.Debug, and it seems that all code related to the static class Debug gets completely removed when the Release configuration is built. I was wondering how the compiler knows that. Maybe there is some class or configuration attribute that allows to specify exactly that behavior.
I am trying to create some debugging code that I want completely removed from the Release configuration, and I was wondering if I could do it just like the Debug class where simply changing the configuration parameters removes the code.
You can apply the ConditionalAttribute attribute, with the string "DEBUG" to any method and calls to that item will only be present in DEBUG builds.
This differs from using the #ifdef approach as this allows you to release methods for use by other people in their DEBUG configurations (like the Debug class methods in the .NET framework).
Visual Studio defines a DEBUG constant for the Debug configuration and you can use this to wrap the code that you don't want executing in your Release build:
#ifdef DEBUG
// Your code
#endif
However, you can also decorate a method with a Conditional attribute, meaning that the method will never be called for non-Debug builds (the method and any call-sites will be removed from the assembly):
[Conditional("DEBUG")]
private void MyDebugMethod()
{
// Your code
}
Have a look at preprocessor directives...
#if DEBUG
//code
#endif