9.5 Pre-processing directives

9.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.
[Note: The term .pre-processing directives.
is used only for consistency with the C and C++ programming languages. In
C#, there is no separate preprocessing
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
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 conditionally skip
sections of source code (§9.5.1).
. #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).
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, preprocessing
directives can be used to include or exclude sequences of tokens and can in
that way affect the
meaning of a C# program. [Example: For example, when compiled, the program
#define A
#undef B
class C
{
#if A
void F() {}
#else
void G() {}
#endif
Chapter 9 Lexical structure
63
#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]