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

?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

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

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]