2.5 Pre-processing directives

The pre-processing directives provide the ability to conditionally skip sections of source files, to report error and warning conditions, and to delineate distinct regions of source code. 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.

pp-directive:

pp-declaration
pp-conditional
pp-line
pp-diagnostic
pp-region

The following pre-processing directives are available:

• #define and #undef, which are used to define and undefine, respectively, conditional compilation symbols (Section 2.5.3).
• #if, #elif, #else, and #endif, which are used to conditionally skip sections of source code (Section 2.5.4).
• #line, which is used to control line numbers emitted for errors and warnings (Section 2.5.7).
• #error and #warning, which are used to issue errors and warnings, respectively (Section 2.5.5).
• #region and #endregion, which are used to explicitly mark sections of source code (Section 2.5.6).

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 may 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 may 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, pre-processing directives can be used to include or exclude sequences of tokens and can in that way affect the meaning of a C# program. For 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 the two programs are quite different lexically, they are identical syntactically.