Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Industrial programming >> C Taal

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# −

Sr.nr. Preprocessorrichtlijn en beschrijving
1

#define

Het definieert een reeks karakters, het zogenaamde symbool.

2

#undef

Hiermee kunt u een symbool ongedaan maken.

3

#if

Hiermee kunt u een symbool of symbolen testen om te zien of ze waar zijn.

4

#else

Het maakt het mogelijk om een ​​samengestelde voorwaardelijke richtlijn te maken, samen met #if.

5

#elif

Hiermee kunt u een samengestelde voorwaardelijke richtlijn maken.

6

#endif

Specificeert het einde van een voorwaardelijke instructie.

7

#line

Hiermee kunt u het regelnummer van de compiler en (optioneel) de uitvoer van de bestandsnaam wijzigen voor fouten en waarschuwingen.

8

#fout

Hiermee kan een fout worden gegenereerd vanaf een specifieke locatie in uw code.

9

#warning

Hiermee kunt u een waarschuwing van niveau één genereren vanaf een specifieke locatie in uw code.

10

#regio

Hiermee kunt u een codeblok specificeren dat u kunt uitvouwen of samenvouwen wanneer u de overzichtsfunctie van de Visual Studio Code Editor gebruikt.

11

#endregion

Het markeert het einde van een #regio-blok.

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 −

Live demo
#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 −

Live demo
#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

C Taal

  1. C# Hello World - Uw eerste C#-programma
  2. C#-zoekwoorden en -ID's
  3. C#-variabelen en (primitieve) gegevenstypen
  4. C#-operators
  5. C# Bitsgewijze en Bit Shift-operators
  6. C# Basisinvoer en -uitvoer
  7. C#-expressies, statements en blokken (met voorbeelden)
  8. C# Opmerkingen
  9. C# switch-instructie
  10. C# ternair (? :) Operator
  11. C# Preprocessor-richtlijnen