C# - Preprocessor-richtlijnen

De preprocessor-richtlijnen geven de compiler instructies om de informatie voor te verwerken voordat de feitelijke compilatie begint.

Alle preprocessor-richtlijnen beginnen met # en alleen witruimtetekens mogen vóór een preprocessor-richtlijn op een regel verschijnen. Preprocessor-richtlijnen zijn geen instructies, dus ze eindigen niet met een puntkomma (;).

C#-compiler heeft geen aparte preprocessor; de richtlijnen worden echter verwerkt alsof er een was. In C# worden de preprocessor-richtlijnen gebruikt om te helpen bij voorwaardelijke compilatie. In tegenstelling tot C- en C++-richtlijnen worden ze niet gebruikt om macro's te maken. Een preprocessor-richtlijn moet de enige instructie op een regel zijn.

Preprocessor-richtlijnen in C#

De volgende tabel bevat de preprocessor-richtlijnen die beschikbaar zijn in C# −

De #define Preprocessor

De #define preprocessor-richtlijn creëert symbolische constanten.

Met #define kunt u een symbool definiëren zodat, door het symbool te gebruiken als de uitdrukking die wordt doorgegeven aan de #if-richtlijn, de uitdrukking wordt geëvalueerd als waar. De syntaxis is als volgt −

#define symbol

Het volgende programma illustreert dit −

#define PI 
using System;

namespace PreprocessorDAppl {
   class Program {
      static void Main(string[] args) {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

PI is defined

Voorwaardelijke richtlijnen

U kunt de #if-richtlijn gebruiken om een ​​voorwaardelijke richtlijn te maken. Voorwaardelijke richtlijnen zijn handig voor het testen van een symbool of symbolen om te controleren of ze als waar worden beoordeeld. Als ze wel naar waar worden geëvalueerd, evalueert de compiler alle code tussen de #if en de volgende instructie.

Syntaxis voor voorwaardelijke richtlijn is −

#if symbol [operator symbol]...

Waar, symbool is de naam van het symbool dat u wilt testen. U kunt ook waar en onwaar gebruiken of het symbool voor de ontkenningsoperator plaatsen.

Het operatorsymbool is de operator die wordt gebruikt voor het evalueren van het symbool. Operators kunnen een van de volgende zijn −

• ==(gelijkheid)
• !=(ongelijkheid)
• &&(en)
• || (of)

U kunt symbolen en operators ook groeperen met haakjes. Voorwaardelijke richtlijnen worden gebruikt voor het compileren van code voor een debug-build of bij het compileren voor een specifieke configuratie. Een voorwaardelijke richtlijn die begint met een #if richtlijn moet expliciet worden beëindigd met een #endif richtlijn.

Het volgende programma demonstreert het gebruik van voorwaardelijke richtlijnen −

#define DEBUG
#define VC_V10
using System;

public class TestClass {
   public static void Main() {
      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG and VC_V10 are defined");
      #else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
      #endif
      Console.ReadKey();
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

DEBUG and VC_V10 are defined