C# - Preprocessor Directives

---

---

The preprocessor directives give instruction to the compiler to preprocess the information before actual compilation starts.

All preprocessor directives begin with #, and only white-space characters may appear before a preprocessor directive on a line. Preprocessor directives are not statements, so they do not end with a semicolon (;).

C# compiler does not have a separate preprocessor; however, the directives are processed as if there was one. In C# the preprocessor directives are used to help in conditional compilation. Unlike C and C++ directives, they are not used to create macros. A preprocessor directive must be the only instruction on a line.

Preprocessor Directives in C#

The following list shows the preprocessor directives available in C# −

The #define Preprocessor

The #define preprocessor directive creates symbolic constants.

#define lets you define a symbol such that, by using the symbol as the expression passed to the #if directive, the expression evaluates to true −

Following is the syntax of #define preprocessor −

#define symbol

Example

The following Example demonstrates the use of #define preprocessor. Here, we use define the PI −

#define PI 
using System;
namespace PreprocessorDAppl {
   class Program {
      static void Main(string[] args) {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

When the above code is compiled and executed, it produces the following result −

PI is defined

Conditional Directives

You can use the #if directive to create a conditional directive. Conditional directives are useful for testing a symbol or symbols to check if they evaluate to true. If they do evaluate to true, the compiler evaluates all the code between the #if and the next directive.

Following is the syntax of the conditional directives −

#if symbol [operator symbol]...

Where, symbol is the name of the symbol you want to test. You can also use true and false or prepend the symbol with the negation operator.

The operator symbol is the operator used for evaluating the symbol. Operators could be either of the following −

• == (equality)
• != (inequality)
• && (and)
• || (or)

You can also group symbols and operators with parentheses. Conditional directives are used for compiling code for a debug build or when compiling for a specific configuration. A conditional directive beginning with a #if directive must explicitly be terminated with a #endif directive.

Example

The following program demonstrates the use of conditional directives −

#define DEBUG
#define VC_V10
using System;

public class TestClass {
   public static void Main() {
      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG and VC_V10 are defined");
      #else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
      #endif
      Console.ReadKey();
   }
}

When the above code is compiled and executed, it produces the following result −

DEBUG and VC_V10 are defined

The #line Preprocessor

The #line preprocessor directive changes the line number and filename reported by the compiler in warnings and errors.

Following is the syntax of #line preprocessor −

#line number "filename"

Example

The following example demonstrates the use of #line preprocessor −

using System;
class Program {
   static void Main() {
      Console.WriteLine("Before #line directive");

      #line 100 "MyFile.cs"
      Console.WriteLine("This line number is 100 in MyFile.cs");

      #line default
      Console.WriteLine("After #line directive");
   }
}

When the above code is compiled and executed, it produces the following result −

Before #line directive
This line number is 100 in MyFile.cs
After #line directive

The #error Preprocessor

The #error preprocessor directive generates a custom error message and stops compilation.

Following is the syntax of #error preprocessor −

#error "Custom error message"

Example

The following example demonstrates the use of #error preprocessor. The compilation will stop if DEBUG_MODE is defined −

#define DEBUG_MODE
using System;
class Program {
   static void Main() {
      #if DEBUG_MODE
         #error "Debug mode is enabled. Disable it before compiling."
      #endif
      
      Console.WriteLine("Program running normally.");
   }
}

When the above code is compiled, it produces the following error −

Compilation failed: 1 error(s), 0 warnings
main.cs(7,0): error CS1029: #error: '"Debug mode is enabled. Disable it before compiling."'

The #warning Preprocessor

The #warning preprocessor directive generates a custom warning message during compilation.

Following is the syntax of #warning preprocessor −

#warning "Custom warning message"

Example

The following example demonstrates the use of #warning preprocessor. A warning is displayed if BETA_VERSION is defined −

#define BETA_VERSION
using System;
class Program {
   static void Main() {
      #if BETA_VERSION
         #warning "This is a beta version. Use at your own risk."
      #endif
      
      Console.WriteLine("Program running normally.");
   }
}

When the above code is compiled, it produces the following warning −

Compilation succeeded - 1 warning(s)
main.cs(7,0): warning CS1030: #warning: `"This is a beta version. Use at your own risk."'
Program running normally.

The #region and #endregion Preprocessor

The #region and #endregion directives help organize code by defining collapsible regions in IDEs like Visual Studio.

Following is the syntax of #region and #endregion preprocessor −

#region RegionName
   // Code inside region
#endregion

Example

The following example demonstrates the use of #region and #endregion preprocessor −

using System;
class Program {
   static void Main() {
      Console.WriteLine("Code outside region");

      #region Math Operations
      int a = 10, b = 20;
      int sum = a + b;
      Console.WriteLine("Sum: " + sum);
      #endregion

      Console.WriteLine("Code outside region");
   }
}

When the above code is compiled and executed, it produces the following result −

Code outside region
Sum: 30
Code outside region