C# – Conditional compilation

You can exclude specific code from being compiled by using conditional compilation symbols.

There are a few predefined symbols that support common scenarios – conditional compilation based on target framework (ex: .NET 5 vs .NET Core 3.1) and based on build configuration (Debug vs Release). In addition, you can add your own symbols to handle any scenario you run into.

In this article, I’ll show how to conditionally compile code based on two common scenarios (target framework and build configuration), and then show how to add your own symbols to support a unique scenario.

Conditionally compile code based on the target framework

If you are targeting multiple frameworks, you may want to conditionally compile code based on the target framework.

For example, let’s say you’re multi-targeting .NET 5.0 and .NET Core 3.1. You can conditionally compile blocks of code depending on the framework like this:

static void Main(string[] args) { Test(); Console.ReadLine(); } #if NET5_0 public static void Test() { Console.WriteLine("I'm running in .NET 5"); } #elif NETCOREAPP3_1 public static void Test() { Console.WriteLine("I'm running in .NET Core 3.1"); } #endif
Code language: C# (cs)
  • Execute the .NET 5 executable in bin/Debug/net5.0/example.exe

This outputs:

I'm running in .NET 5
Code language: plaintext (plaintext)
  • Execute the .NET Core 3.1 executable in bin/Debug/netcoreapp3.1/example.exe

This outputs:

I'm running in .NET Core 3.1
Code language: plaintext (plaintext)

Conditionally compile code based on the build config (Debug vs Release)

Sometimes you’ll have code that you only want to include in a debug build. Usually only devs will use debug builds in a dev environment, and everyone else will use release builds. So you can include functionality in a debug build that should only be available to devs.

For example, let’s say you have a command line utility that lets the user enter a command. One of the commands is “Push the little red button.” There’s a recurring joke in movies where there’s a little red button, and one of the characters says to the other “Just don’t push the little red button.”

Instead of asking users to not execute this command, just compile it out if it’s not a debug build, like this:

static void Main(string[] args) { Console.WriteLine("Commands:"); Console.WriteLine("1 - Send a request"); Console.WriteLine("2 - Check for new messages"); #if DEBUG Console.WriteLine("3 - Push the little red button"); #endif var command = Console.ReadLine(); switch (command) { case "1": SendRequest(); break; case "2": CheckForNewMessages(); break; #if DEBUG case "3": PushTheLittleRedButton(); break; #endif } }
Code language: C# (cs)

When someone uses the release build, the “Push the little button red” command will be compiled out, and they’ll only see the other options:

Commands: 1 - Send a request 2 - Check for new messages
Code language: plaintext (plaintext)

Adding your own conditional compilation symbols

You can add any conditional compilation symbol you want. You can add them at the project level or file level. I’ll show examples of both ways to add them below.

First, here’s some code that uses a custom conditional compilation symbol called INCLUDE_SLOW_TESTS. Let’s say you have slow unit tests and sometimes you want to exclude them during development. In other words, you want to include the slow tests if it’s a release build or if the INCLUDE_SLOW_TESTS symbol is defined.

[TestClass()] public class TestThings { [TestMethod()] public void FastTest1() { //fast test 1 } #if !DEBUG || INCLUDE_SLOW_TESTS [TestMethod()] public void SlowTest1() { //slow test 1 } #endif [TestMethod()] public void FastTest2() { //fast test 1 } #if !DEBUG || INCLUDE_SLOW_TESTS [TestMethod()] public void SlowTest2() { //slow test 1 } #endif }
Code language: C# (cs)

Note: You could also comment out the slow tests, but commenting / uncommenting tests would be time-consuming, especially if you have lots of tests.

Adding conditional compilation symbols at the project level

It’s a good idea to add the conditional compilation symbol at the project level if you’re using it in multiple files.

  • Right-click the project > Properties.
  • Go in the Build tab.
  • Select the Configuration and Platform you want to define the symbol for.
  • In the Conditional compilation symbols textbox, put the symbols you want to define (if you have more than one, separate them with a semicolon).
Project properties > Build tab > Specify the custom conditional compilation symbols you want and Configuration/Platform you want it to apply to

Take a look in the .csproj file, and notice that it added DefineConstants property:

<Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <TargetFramework>net5.0</TargetFramework> <IsPackable>false</IsPackable> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"> <DefineConstants>TRACE;INCLUDE_SLOW_TESTS</DefineConstants> </PropertyGroup> <ItemGroup> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" /> <PackageReference Include="MSTest.TestAdapter" Version="2.1.1" /> <PackageReference Include="MSTest.TestFramework" Version="2.1.1" /> <PackageReference Include="coverlet.collector" Version="1.3.0" /> </ItemGroup> <ItemGroup> <ProjectReference Include="..\ConditionalCompliation\ConditionalCompliation.csproj" /> </ItemGroup> </Project>
Code language: HTML, XML (xml)

If you’ve defined a symbol at the project level, and you want to undefine it for a single file, you can undefine it in that file:

Code language: C# (cs)

Adding conditional compilation symbols at the file level

If you’re only using a symbol in a single file, then you can define the symbol in the file itself, like this:

#define INCLUDE_SLOW_TESTS using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ConditionalCompliation.Tests { [TestClass()] public class TestItTests { [TestMethod()] public void FastTest1() { //fast test 1 } #if !DEBUG || INCLUDE_SLOW_TESTS [TestMethod()] public void SlowTest1() { //slow test 1 } #endif //the rest of the code
Code language: C# (cs)

To undefine the symbol:

  • Comment out the define line:
Code language: C# (cs)
  • or undefine it:
Code language: C# (cs)

Leave a Comment