Introduction

In C#, #if DEBUG works only because the DEBUG symbol is usually defined for Debug builds. #if RELEASE does not work automatically unless you define a RELEASE symbol yourself. The important distinction is that build configuration names and conditional-compilation symbols are related by project settings, not by magic language rules.

How Conditional Compilation Actually Works

C# preprocessor directives check whether a symbol is defined at compile time.

#if DEBUG
Console.WriteLine("Debug build");
#endif

This works when the compiler sees DEBUG in the defined symbols list for that build.

The compiler does not automatically infer symbols from the names “Debug” and “Release.” It just checks the symbol table provided by project settings or compiler flags.

Why #if DEBUG Usually Works

Most .NET project templates define DEBUG for the Debug configuration by default. That is why developers often assume DEBUG is special syntax. It is not special in the language; it is just commonly predefined.

Example command-line compilation:

csc /define:DEBUG Program.cs

This defines DEBUG, so #if DEBUG blocks are included.

Why #if RELEASE Usually Does Not Work by Default

Many projects do not define a RELEASE symbol automatically, even if the build configuration is named Release. So this may do nothing:

#if RELEASE
Console.WriteLine("Release build");
#endif

If RELEASE is not defined in project settings, the compiler excludes that block.

How to Make #if RELEASE Work

You can explicitly define the symbol in your Release configuration.

In a project file, that might look like:

<PropertyGroup Condition="'$(Configuration)' == 'Release'">
  <DefineConstants>TRACE;RELEASE</DefineConstants>
</PropertyGroup>

Or via command line:

csc /define:RELEASE Program.cs

After that, #if RELEASE will behave as expected because the symbol now exists.

Better Pattern: Prefer Positive Intent

In many projects, developers use:

1#if DEBUG
2// debug-only code
3#else
4// non-debug code
5#endif

This is often clearer than relying on a separate RELEASE symbol, because it expresses intent directly: one branch is debug-only, the other is everything else.

It also avoids subtle mistakes if you later add more custom build configurations such as Staging or Benchmark.

TRACE and Other Built-In Conventions

Another common symbol is TRACE, which is often defined in both Debug and Release builds. Do not assume symbol meaning without checking project settings. Different repositories can define additional custom symbols, and older projects may use conventions differently from newer SDK-style projects.

When to Use Conditional Compilation at All

Preprocessor directives are useful for:

• debug-only diagnostics
• platform-specific compilation
• feature flags that must disappear from the binary

They are not ideal for normal runtime behavior switches. If the decision should happen while the app is running, use configuration or regular if statements instead.

Check the Actual Defined Symbols

When in doubt, inspect project settings instead of guessing. In Visual Studio or SDK-style project files, the defined constants for each configuration are explicit. This matters because teams often add custom configurations such as Staging, Benchmark, or CI, and those may define different symbols from the standard Debug and Release defaults.

Common Pitfalls

• Assuming RELEASE is automatically defined because the build configuration is named Release.
• Confusing configuration names with compiler symbols.
• Using preprocessor directives for logic that should be runtime-configurable.
• Not checking project or build settings before relying on a symbol.
• Creating many custom symbols and making builds hard to reason about.

Summary

• '#if DEBUG works only because DEBUG is commonly defined by build settings.'
• '#if RELEASE does not work automatically unless you define RELEASE yourself.'
• Build configuration names are not the same as compiler symbols.
• '#if DEBUG ... #else ... #endif is often simpler than introducing RELEASE.'
• Use conditional compilation for compile-time concerns, not ordinary runtime choices.