ASP.NET: how can I compile in DEBUG mode?

Question

AFAIK, usual ASP.NET web site/web application switched on into DEBUG mode when web/app-config setting "compilation" has debug="false".

But I don't clearly understand how it works. Let's consider example:

I have <compilation debug="true" />. I've added the following line into "Page_Load" method:

 System.Diagnostics.Debug.WriteLine("Page_Load");

When I launched web-site in 'debug' mode (using F5 button) It put me 'Page_Load' into output window. Everything is ok so far.

When I change application compilation mode into non-debug:

Will it recompile everything for 'non-debug' mode? Is this enough to go into "production" environment with this change only?

I guess, it should be enough for web-site that doesn't use other project. Otherwise, I would better switch whole configuration into "Release" mode. In this case EACH project will be recompiled in "Release" mode.

Am I right? Could you please point me if something is wrong here?

Thanks a lot!

Answer 1

The point about your question is the difference between compiling in Visual Studio's Debug/Release modes and the Web.config's debug flag.

I'll try to explain you both.

First of all, you must get to know how an ASP.NET application is compiled, otherwise you won't understand the difference between the two compilations.

An ASP.NET application is made by markup (ie. .aspx pages, .ascx controls, .ashx .asmx marker files) and code-behind. Code-behind, from your IDE's point of view (no matter Visual Studio, MonoDevelop, etc.) is a .NET Class Library, ie. a set of classes that don't do anything alone. These can be compiled into Debug or Release mode indifferently by IDE setting. If you compile into Release mode, then calls to Debug class will be ignored.

What about markup? When you start the web application, the markup files get compiled by the application server to get the final assemblies. For example, a Default.aspx page with a code-behind file is compiled into a final class that inherits the code-behind class and writes to HTTP output all of its static parts, plus all the controls instantiated in the base class in the positions that have been chosen during design. Inline code (ie. <script runat=server> tags) gets compiled too. In order to choose the compilation mode, the debug flag in Web.config is used, because you can't determine for sure if an assembly has been compiled in debug or release mode by simply reflecting on it (though there could be some empyrical criteria).

In a few words

1. When you call Debug class from code-behind, make sure that your IDE compiles the website into Debug mode
2. When you call Debug class from inline code in markup, make sure you have Web.config's debug flag set
3. If you deploy your application as source code (it doesn't work for me in Mono, I must first xbuild it), I'm unsure but I believe the debug flag will be used for first compilation stage too

I hope I have been of help!

Answer 2

As I understand it when you change the web.config for a Web Site to disable debugging, the JIT will start from scratch - since all methods in the System.Diagnostics.Debug namespace are marked to be only included in debug mode ( [Conditional("DEBUG")]) the calls won't be there at all in the release build.

For a precompiled Web application in debug mode these calls will be in the DLLs produced, disabling debug at that point will not help you - you need to rebuild/precompile the Web application in release mode before releasing it.