conditional-compilation

I know that if I mark code as DEBUG code it won't run in RELEASE mode, but does it still get compiled into an assembly? I just wanna make sure my assembly isn't bloated by extra methods. [Conditional(DEBUG)] private void DoSomeLocalDebugging() { //debugging } Yes, the method itself still is built however you compile. This is entirely logical - because the point of Conditional is to depend on the preprocessor symbols defined when the caller is built, not when the callee is built. Simple test - build this: using System; using System.Diagnostics; class Test { [Conditional("FOO")] static void

What is the conditional to check if assertions are active in Delphi? I would like to be able to do something to suppress hints about unused variables when assertions are not active in code like procedure Whatever; var v : Integer; begin v := DoSomething; Assert(v >= 0); end; In the above code, when assertions are not active, there is a hint about variable v being assigned a value that is never used. The code is in a library which is going to be used in various environments, so I'd be able to test for assertions specifically, and not a custom conditional like DEBUG. You can do this using the

This question already has answers here : Closed 6 years ago . Possible Duplicate: Conditional compilation and framework targets I have some code that works in .NET 4, but it does not work in .NET 3.5. In .NET 3.5 it requires to use interop calls to Windows. I would like using a "ifdef" to use a different code path in both cases (eventually I will deprecate the .NET 3.5 code). Is there a pre-defined directive value to identify when the code is compiled with .NET 4? Is there a good link with all the predefined directives ( DEBUG , TRACE , etc.)? The page below only gives the directives, but not

I'm writing an assembly with some conditionally compiled members in it, e.g.: [Conditional("DEBUG")] public static void Log(string message) { /*...*/ } And using it like so: public void DoStuff() { Log("This will only appear on debug builds"); /* ... Do stuff ... */ } But when I give this assembly to someone to use in their project, I want them to be able to define whether or not DEBUG-conditional members are compiled. If that's not possible (e.g. the methods are just completely removed at compile-time), then is there any way to package multiple 'configurations' of an assembly (e.g. maybe with

People recommend #ifdef for conditional compilation by a wide margin . A search for #ifdef substantiates that its use is pervasive. Yet #ifdef NAME (or equivalently #if defined(NAME) and related #ifndef NAME (and #if !defined(NAME) ) have a severe flaw: header.h #ifndef IS_SPECIAL #error You're not special enough #endif source.cpp #include "header.h" gcc -DIS_SPECIAL source.cpp will pass, obviously, as will source1.cpp #define IS_SPECIAL 1 #include "header.h" But, so will source0.cpp #define IS_SPECIAL 0 #include "header.h" which is quite the wrong thing to do. And some C++ compilers, passed a

How can I do something similar to the following C code in VB 6? #ifdef _DEBUG_ // do things #else // do other things #end if It's pretty much the same as the other languages that you're used to. The syntax looks like this: #If DEBUG = 1 Then ' Do something #Else ' Do something else #End If It's easy to remember if you just remember that the syntax is exactly the same as the other flow-control statements in VB 6, except that the compile-time conditionals start with a pound sign ( # ). The trick is actually defining the DEBUG (or whatever) constant because I'm pretty sure that there isn't one