Debug or Release ?

  • Thread starter Thread starter mikemeamail
  • Start date Start date
M

mikemeamail

Hi everybody,

Is there a simple way to know from the code if an assembly is in debug
or release mode ?

Concretely, when my application is running, i'd like to know in which
mode it is configured.

Any help appreciated.

Mike
 
Hi Mike,

You can assign a variable using conditional compilation:

#if DEBUG
bool debug = true;
#else
bool debug = false;
#endif

(Note that the code actually defines the variable twice but only one version
will be compiled)

If you want to check at runtime whether the DEBUG symbol is defined in the
calling assembly then you can do this:

private bool debug = false;

private void Initialize()
{
// this method call will be omitted when the
// DEBUG symbol is not defined during runtime
// so the debug variable will remain false
CheckDebug();
}

[Conditional("DEBUG")] // this is the important part :)
private void CheckDebug()
{
debug = true;
}
 
No.
There is no complex way either.

You've got the lucky way though.
You could browse through all methods, and if some have the
ConditionalAttribute() you could check which condition it is.
 
Ok,
Thanks a lot guys for your help.
Mike

Lloyd said:
No.
There is no complex way either.

You've got the lucky way though.
You could browse through all methods, and if some have the
ConditionalAttribute() you could check which condition it is.
Click to expand...
 
Hi Lloyd,

What do you mean by "the lucky way"?

And you don't need to browse the metadata for the ConditionalAttribute - the
strategy that I posted works fine.
 
How about using Application.Startup path and searching for the dtring
Debug or release within the appp's startup path (.FullName) - vs builds
your exe into either a debug or release folder. just an idea.
 
Hi,

You'd be better off using conditional compilation, which is guaranteed to be
accurate. If you need to detect whether a caller has the debug symbol
defined then you can use the ConditionalAttribute strategy that I posted in
my original response, which is also guaranteed to be accurate.

Realize, however, that there is really no way of knowing whether an assembly
is in "release" mode since there is no standardized symbol that indicates a
release build. It's the "debug" symbol's presence, or lack thereof, that
can be used to determine whether an assembly is in "debug" mode since that
symbol is standardized. The "debug" symbol is used by some types in the
System.Diagnostics namespace of the FCL and by Visual Studio when building
in the "Debug" configuration. When the "debug" symbol isn't present, then
it might be safe to assume that the build is for release. If it's your own
assembly than it should be clear, but for a third-party assembly it might
not be.
 
Mike,

A slight variation to Dave's suggestion is to take advantage of the
AssemblyConfiguration attribute.

#if DEBUG
[assembly: AssemblyConfiguration("Debug")]
#else
[assembly: AssemblyConfiguration("Release")]
#endif

You can then query the assembly at runtime for this attribute or
examine the manifest with ILDASM or .NET Reflector to verify the build
configuration.

Brian
 
Your strategy create block which will go in either release.
That was not the question as I understood it.
The question, if I'm correct, is how could you use something (like
reflection) to browse throught the compiled assemblies and know what
compilation flags where used.

To answer the question I understood, which I seem to be the only one to
understood this way, you've got to do as I suggested (maybe there are other
strategies I don't know of, though..) and IF (and only IF) there was some
conditional method in the original source code which get compile, you might
know. It's why you need to be lucky, because there might be no such
method....
 
Hi Lloyd,

I disagree about what the OP wanted, but even if the OP did want to know how
reflection could be used to discover debug symbols then the answer would
certainly not be to look for the ConditionalAttribute.

"[ConditionalAttribute i]ndicates to compilers that a method call or
attribute should be ignored unless a specified conditional compilation
symbol is defined."

ConditionalAttribute Class
http://msdn2.microsoft.com/en-us/library/system.diagnostics.conditionalattribute.aspx

The ConditionalAttribute isn't placed on your methods by Visual Studio or
the C# compiler. You must add it yourself. It's used by classes in the
System.Diagnostics namespace such as Debug and Trace, for example, so that
calls will be omitted depending on the build configuration.

My suggestion works since a call to a method with the ConditionalAttribute
is omitted when the calling assembly does not have the DEBUG symbol defined.
It does not require recompilation of the calling assembly or the assembly in
which the method is defined. If that was true then the System.Diagnostics
classes wouldn't work either.

As I understood it, this is what the OP wanted to know how to accomplish.

To be perfectly honest, I don't think it's even possible to examine debug
symbols using reflection.
 
Nice tip Brian! Thanks.

Jason Newell
www.jasonnewell.net


Brian said:
Mike,

A slight variation to Dave's suggestion is to take advantage of the
AssemblyConfiguration attribute.

#if DEBUG
[assembly: AssemblyConfiguration("Debug")]
#else
[assembly: AssemblyConfiguration("Release")]
#endif

You can then query the assembly at runtime for this attribute or
examine the manifest with ILDASM or .NET Reflector to verify the build
configuration.

Brian

Hi everybody,

Is there a simple way to know from the code if an assembly is in debug
or release mode ?

Concretely, when my application is running, i'd like to know in which
mode it is configured.

Any help appreciated.

Mike
Click to expand...
Click to expand...
 
Back
Top