9.5.4 Conditional compilation directives
The conditional compilation directives are used to conditionally include or
exclude portions of a source file.
pp-conditional::
pp-if-section pp-elif-sectionsopt pp-else-sectionopt pp-endif
pp-if-section::
whitespaceopt # whitespaceopt if whitespace pp-expression pp-new-line
conditional-sectionopt
pp-elif-sections::
pp-elif-section
pp-elif-sections pp-elif-section
pp-elif-section::
whitespaceopt # whitespaceopt elif whitespace pp-expression pp-new-line
conditional-sectionopt
pp-else-section::
whitespaceopt # whitespaceopt else pp-new-line conditional-sectionopt
pp-endif::
whitespaceopt # whitespaceopt endif pp-new-line
conditional-section::
input-section
skipped-section
skipped-section::
skipped-section-part
skipped-section skipped-section-part
skipped-section-part::
skipped-charactersopt new-line
pp-directive
skipped-characters::
whitespaceopt not-number-sign input-charactersopt
not-number-sign::
Any input-character except #
[Note: As indicated by the syntax, conditional compilation directives must
be written as sets consisting of, in
order, an #if directive, zero or more #elif directives, zero or one #else
directive, and an #endif directive.
Between the directives are conditional sections of source code. Each
section is controlled by the immediately
preceding directive. A conditional section may itself contain nested
conditional compilation directives provided
these directives form complete sets. end note]
A pp-conditional selects at most one of the contained conditional-sections
for normal lexical processing:
C# LANGUAGE SPECIFICATION
66
?The pp-expressions of the #if and #elif directives are evaluated in order
until one yields true. If an
expression yields true, the conditional-section of the corresponding
directive is selected.
?If all pp-expressions yield false, and if an #else directive is present,
the conditional-section of the #else
directive is selected.
?Otherwise, no conditional-section is selected.
The selected conditional-section, if any, is processed as a normal
input-section: the source code contained in the
section must adhere to the lexical grammar; tokens are generated from the
source code in the section; and preprocessing
directives in the section have the prescribed effects.
The remaining conditional-sections, if any, are processed as
skipped-sections: except for pre-processing
directives, the source code in the section need not adhere to the lexical
grammar; no tokens are generated from
the source code in the section; and pre-processing directives in the
section must be lexically correct but are not
otherwise processed. Within a conditional-section that is being processed
as a skipped-section, any nested
conditional-sections (contained in nested #if...#endif and
#region...#endregion constructs) are also
processed as skipped-sections.
[Example: The following example illustrates how conditional compilation
directives can nest:
#define Debug // Debugging on
#undef Trace // Tracing off
class PurchaseTransaction
{
void Commit() {
#if Debug
CheckConsistency();
#if Trace
WriteToLog(this.ToString());
#endif
#endif
CommitHelper();
}
.
}
Except for pre-processing directives, skipped source code is not subject to
lexical analysis. For example, the
following is valid despite the unterminated comment in the #else section:
#define Debug // Debugging on
class PurchaseTransaction
{
void Commit() {
#if Debug
CheckConsistency();
#else
/* Do something else
#endif
}
.
}
Note, however, that pre-processing directives are required to be lexically
correct even in skipped sections of
source code.
Pre-processing directives are not processed when they appear inside
multi-line input elements. For example, the
program:
Chapter 9 Lexical structure
67
class Hello
{
static void Main() {
System.Console.WriteLine(@"hello,
#if Debug
world
#else
Nebraska
#endif
");
}
}
results in the output:
hello,
#if Debug
world
#else
Nebraska
#endif
In peculiar cases, the set of pre-processing directives that is processed
might depend on the evaluation of the ppexpression.
The example:
#if X
/*
#else
/* */ class Q { }
#endif
always produces the same token stream (class Q { }), regardless of whether
or not X is defined. If X is defined,
the only processed directives are #if and #endif, due to the multi-line
comment. If X is undefined, then three
directives (#if, #else, #endif) are part of the directive set. end example]
