C # - Direttive del preprocessore

Le direttive del preprocessore danno istruzioni al compilatore di preelaborare le informazioni prima che inizi la compilazione effettiva.

Tutte le direttive del preprocessore iniziano con # e solo i caratteri spazi bianchi possono apparire prima di una direttiva del preprocessore su una riga. Le direttive del preprocessore non sono istruzioni, quindi non terminano con un punto e virgola (;).

Il compilatore C # non dispone di un preprocessore separato; tuttavia, le direttive vengono elaborate come se ce ne fosse una. In C # le direttive del preprocessore vengono usate per aiutare nella compilazione condizionale. A differenza delle direttive C e C ++, non vengono utilizzate per creare macro. Una direttiva del preprocessore deve essere l'unica istruzione su una riga.

Direttive del preprocessore in C #

La tabella seguente elenca le direttive del preprocessore disponibili in C # -

Sr.No. Direttiva e descrizione del preprocessore
1

#define

Definisce una sequenza di caratteri, chiamata simbolo.
2

#undef

Ti permette di indefinire un simbolo.
3

#if

Consente di testare uno o più simboli per vedere se restituiscono true.
4

#else

Permette di creare una direttiva condizionale composta, insieme a #if.
5

#elif

Consente di creare una direttiva condizionale composta.
6

#endif

Specifica la fine di una direttiva condizionale.
7

#line

Consente di modificare il numero di riga del compilatore e (facoltativamente) l'output del nome del file per errori e avvisi.
8

#error

Consente di generare un errore da una posizione specifica nel codice.
9

#warning

Consente di generare un avviso di livello uno da una posizione specifica nel codice.
10

#region

Consente di specificare un blocco di codice che è possibile espandere o comprimere quando si utilizza la funzionalità di struttura dell'Editor di codice di Visual Studio.
11

#endregion

Segna la fine di un blocco #region.

Il preprocessore #define

La direttiva del preprocessore #define crea costanti simboliche.

#define consente di definire un simbolo in modo tale che, utilizzando il simbolo come espressione passata alla direttiva #if, l'espressione restituisca true. La sua sintassi è la seguente:

#define symbol

Il seguente programma lo illustra:

#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();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

PI is defined

Direttive condizionali

È possibile utilizzare la direttiva #if per creare una direttiva condizionale. Le direttive condizionali sono utili per testare uno o più simboli per verificare se restituiscono true. Se restituiscono true, il compilatore valuta tutto il codice compreso tra #if e la direttiva successiva.

La sintassi per la direttiva condizionale è -

#if symbol [operator symbol]...

Dove, symbol è il nome del simbolo che vuoi testare. È inoltre possibile utilizzare true e false o anteporre al simbolo l'operatore di negazione.

Il simbolo dell'operatore è l'operatore utilizzato per valutare il simbolo. Gli operatori potrebbero essere uno dei seguenti:

  • == (uguaglianza)
  • ! = (disuguaglianza)
  • && (e)
  • || (o)

Puoi anche raggruppare simboli e operatori con parentesi. Le direttive condizionali vengono utilizzate per compilare codice per una build di debug o durante la compilazione per una configurazione specifica. Una direttiva condizionale che inizia con a#if la direttiva deve essere terminata esplicitamente con a #endif direttiva.

Il seguente programma dimostra l'uso di direttive condizionali:

#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();
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

DEBUG and VC_V10 are defined