9.5 Pre-processing directives

The pre-processing directives provide the ability to skip conditionally sections of source files, to report error and warning conditions, and to delineate distinct regions of source code. [Note: The term "pre-processing directives" is used only for consistency with the C and C++ programming languages. In C#, there is no separate pre-processing step; pre-processing directives are processed as part of the lexical analysis phase. end note]

pp-directive::

pp-declaration

pp-conditional

pp-line

pp-diagnostic

pp-region

pp-pragma

The following pre-processing directives are available:

• #define and #undef, which are used to define and undefine, respectively, conditional compilation

symbols (§9.5.3).

• #if, #elif, #else, and #endif, which are used to skip conditionally sections of source code (§9.5.4).

• #line, which is used to control line numbers emitted for errors and warnings (§9.5.7).

• #error and #warning, which are used to issue errors and warnings, respectively (§9.5.5).

• #region and #endregion, which are used to explicitly mark sections of source code (§9.5.6).

• #pragma, which is used to provide contextual information to a compiler (§9.5.8).

A pre-processing directive always occupies a separate line of source code and always begins with a # character and a pre-processing directive name. White space can occur before the # character and between the # character and the directive name.

A source line containing a #define, #undef, #if, #elif, #else, #endif, or #line directive can end with a single-line comment. Delimited comments (the /* */ style of comments) are not permitted on source lines containing pre-processing directives.

Pre-processing directives are not tokens and are not part of the syntactic grammar of C#. However, preprocessing directives can be used to include or exclude sequences of tokens and in that way can affect the meaning of a C# program. [Example: When compiled, the program

#define A
#undef B
 
class C
{
#if A
  void F() {}
#else
  void G() {}
#endif
#if B
  void H() {}
#else
  void I() {}
#endif
}

results in the exact same sequence of tokens as the program

class C
{
  void F() {}
  void I() {}
}

Thus, whereas lexically, the two programs are quite different, syntactically, they are identical. end example]