#ifndef _DEBUG equivalent...

[Daniel Bass]

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif

where you can set different code to be included in different builds. Useful
for having a logging system for debugging only when compiling the project in
Debug, but wanting to turn it off in Release.

It this possible with c#.net? (VS.net 2003)

Thanks!
Dan.

[Serge]

#if DEBUG

// code here only runs in debug mode
#endif

"Daniel Bass" <I'm really @ sick of spam> wrote in message
news:eM**************@tk2msftngp13.phx.gbl...

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif

where you can set different code to be included in different builds. Useful for having a logging system for debugging only when compiling the project in Debug, but wanting to turn it off in Release.

It this possible with c#.net? (VS.net 2003)

Thanks!
Dan.

[Jon Skeet [C# MVP]]

<"Daniel Bass" <I'm really @ sick of spam>> wrote:

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif
I think you meant:

#ifdef _DEBUG

there.

You can do that with C# too:

#if DEBUG
....
#endif
where you can set different code to be included in different builds. Useful
for having a logging system for debugging only when compiling the project in
Debug, but wanting to turn it off in Release.

For that kind of thing it's actually easier to use an attribute on the
method you're calling - look at the Trace class for an example.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Eric Newton]

Also, if you use the Debug statements "Debug.WriteLine", "Debug.*", the c#
and vb.net compilers automatically ignore these statements in release
builds.

--
Eric Newton
C#/ASP Application Developer
http://ensoft-software.com/
er**@cc.ensoft-software.com [remove the first "CC."]

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

<"Daniel Bass" <I'm really @ sick of spam>> wrote:

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif

I think you meant:

#ifdef _DEBUG

there.

You can do that with C# too:

#if DEBUG
...
#endif

where you can set different code to be included in different builds. Useful for having a logging system for debugging only when compiling the project in Debug, but wanting to turn it off in Release.

For that kind of thing it's actually easier to use an attribute on the
method you're calling - look at the Trace class for an example.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Ed Courtenay]

That's not exactly true; the Debug.Write statement will be compiled and
called in both Debug and Release builds. The difference is that in Release
builds the function won't actually do anything as TraceInternal class won't
have any listeners registered.

This means you will still have a (slight) overhead in Release builds
whenever Debug.Write is called.

"Eric Newton" <er**@cc.ensoft-software.com> wrote in message
news:ud*************@tk2msftngp13.phx.gbl...

Also, if you use the Debug statements "Debug.WriteLine", "Debug.*", the c#
and vb.net compilers automatically ignore these statements in release
builds.

--
Eric Newton
C#/ASP Application Developer
http://ensoft-software.com/
er**@cc.ensoft-software.com [remove the first "CC."]

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

<"Daniel Bass" <I'm really @ sick of spam>> wrote:

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif

I think you meant:

#ifdef _DEBUG

there.

You can do that with C# too:

#if DEBUG
...
#endif

where you can set different code to be included in different builds. Useful for having a logging system for debugging only when compiling the project in Debug, but wanting to turn it off in Release.

For that kind of thing it's actually easier to use an attribute on the
method you're calling - look at the Trace class for an example.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Daniel Bass]

Will it? I mean, the optimiser in the compiler in release mode will say that
the procedure call is empty, and has no effect, therefore the call is
altogether elliminated...

"Ed Courtenay" <my***********@edcourtenay.co.uk> wrote in message
news:O9**************@TK2MSFTNGP10.phx.gbl...

That's not exactly true; the Debug.Write statement will be compiled and
called in both Debug and Release builds. The difference is that in Release
builds the function won't actually do anything as TraceInternal class won't
have any listeners registered.

This means you will still have a (slight) overhead in Release builds
whenever Debug.Write is called.

"Eric Newton" <er**@cc.ensoft-software.com> wrote in message
news:ud*************@tk2msftngp13.phx.gbl...

Also, if you use the Debug statements "Debug.WriteLine", "Debug.*", the c#
and vb.net compilers automatically ignore these statements in release
builds.

--
Eric Newton
C#/ASP Application Developer
http://ensoft-software.com/
er**@cc.ensoft-software.com [remove the first "CC."]

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

<"Daniel Bass" <I'm really @ sick of spam>> wrote:

In C++ you can use the following:

#ifndef _DEBUG

// code here only runs in debug mode

#endif

I think you meant:

#ifdef _DEBUG

there.

You can do that with C# too:

#if DEBUG
...
#endif

where you can set different code to be included in different builds. Useful for having a logging system for debugging only when compiling the project in Debug, but wanting to turn it off in Release.

For that kind of thing it's actually easier to use an attribute on the
method you're calling - look at the Trace class for an example.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

Ed Courtenay <my***********@edcourtenay.co.uk> wrote:

That's not exactly true; the Debug.Write statement will be compiled and
called in both Debug and Release builds.

No it won't. Here's a sample program:

using System;
using System.Diagnostics;

class Test
{
static void Main(string[] args)
{
Debug.WriteLine ("Foo");
}
}

Compiled with

csc Test.cs

the IL for Main is:

..method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 1 (0x1)
.maxstack 0
IL_0000: ret
} // end of method Test::Main
Compiled with

csc /D:DEBUG Test.cs

the IL is:

..method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 11 (0xb)
.maxstack 1
IL_0000: ldstr "Foo"
IL_0005: call void [System]System.Diagnostics.Debug::WriteLine
(string)
IL_000a: ret
} // end of method Test::Main
Note the lack of a call in the version where the DEBUG symbol isn't
defined.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Ed Courtenay]

My apologies - from looking through the Debug class with Lutz Roeder's
excellent Reflector, it seems that methods like Debug.Write are marked with
a [Conditional("DEBUG")] attribute. I guess that if the compiler sees this
attribute on a method it drops it from the IL when compiled without the
DEBUG flag.

Is this correct?

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

Ed Courtenay <my***********@edcourtenay.co.uk> wrote:

That's not exactly true; the Debug.Write statement will be compiled and
called in both Debug and Release builds.

No it won't. Here's a sample program:

using System;
using System.Diagnostics;

class Test
{
static void Main(string[] args)
{
Debug.WriteLine ("Foo");
}
}

Compiled with

csc Test.cs

the IL for Main is:

.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 1 (0x1)
.maxstack 0
IL_0000: ret
} // end of method Test::Main
Compiled with

csc /D:DEBUG Test.cs

the IL is:

.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 11 (0xb)
.maxstack 1
IL_0000: ldstr "Foo"
IL_0005: call void [System]System.Diagnostics.Debug::WriteLine
(string)
IL_000a: ret
} // end of method Test::Main
Note the lack of a call in the version where the DEBUG symbol isn't
defined.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

Ed Courtenay <my***********@edcourtenay.co.uk> wrote:

My apologies - from looking through the Debug class with Lutz Roeder's
excellent Reflector, it seems that methods like Debug.Write are marked with
a [Conditional("DEBUG")] attribute. I guess that if the compiler sees this
attribute on a method it drops it from the IL when compiled without the
DEBUG flag.

Is this correct?

Yes, that's exactly correct.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Eric Newton]

Whew, I was nervous when Daniel had said that the call was still being
made... thinking about all the Debug.WriteLine's that I tend to do...!

--
Eric Newton
C#/ASP Application Developer
http://ensoft-software.com/
er**@cc.ensoft-software.com [remove the first "CC."]

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

Ed Courtenay <my***********@edcourtenay.co.uk> wrote:

My apologies - from looking through the Debug class with Lutz Roeder's
excellent Reflector, it seems that methods like Debug.Write are marked with a [Conditional("DEBUG")] attribute. I guess that if the compiler sees this attribute on a method it drops it from the IL when compiled without the
DEBUG flag.

Is this correct?

Yes, that's exactly correct.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Daniel Bass]

I never said such a thing, 'twas not me sir. ;o)

I'm in the same prediciment with calls to the debugger framework i've got
setup.
"Eric Newton" <er**@cc.ensoft-software.com> wrote in message
news:uF**************@TK2MSFTNGP09.phx.gbl...
Whew, I was nervous when Daniel had said that the call was still being
made... thinking about all the Debug.WriteLine's that I tend to do...!

--
Eric Newton
C#/ASP Application Developer
http://ensoft-software.com/
er**@cc.ensoft-software.com [remove the first "CC."]

"Jon Skeet [C# MVP]" <sk***@pobox.com> wrote in message
news:MP************************@msnews.microsoft.c om...

Ed Courtenay <my***********@edcourtenay.co.uk> wrote:

My apologies - from looking through the Debug class with Lutz Roeder's
excellent Reflector, it seems that methods like Debug.Write are marked with a [Conditional("DEBUG")] attribute. I guess that if the compiler sees this attribute on a method it drops it from the IL when compiled without the
DEBUG flag.

Is this correct?

Yes, that's exactly correct.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too