C # - Directives de préprocesseur

Les directives du préprocesseur donnent l'instruction au compilateur de prétraiter les informations avant le début de la compilation réelle.

Toutes les directives de préprocesseur commencent par # et seuls les caractères d'espace blanc peuvent apparaître avant une directive de préprocesseur sur une ligne. Les directives du préprocesseur ne sont pas des instructions, elles ne se terminent donc pas par un point-virgule (;).

Le compilateur C # n'a pas de préprocesseur séparé; cependant, les directives sont traitées comme s'il y en avait une. En C #, les directives du préprocesseur sont utilisées pour aider à la compilation conditionnelle. Contrairement aux directives C et C ++, elles ne sont pas utilisées pour créer des macros. Une directive de préprocesseur doit être la seule instruction sur une ligne.

Directives de préprocesseur en C #

Le tableau suivant répertorie les directives de préprocesseur disponibles en C # -

N ° Sr.	Directive et description du préprocesseur
1	#define Il définit une séquence de caractères, appelée symbole.
2	#undef Il vous permet de définir un symbole.
3	#if Il permet de tester un ou plusieurs symboles pour voir s'ils sont évalués à vrai.
4	#else Il permet de créer une directive conditionnelle composée, avec #if.
5	#elif Il permet de créer une directive conditionnelle composée.
6	#endif Spécifie la fin d'une directive conditionnelle.
sept	#line Il vous permet de modifier le numéro de ligne du compilateur et (facultativement) la sortie du nom de fichier pour les erreurs et les avertissements.
8	#error Il permet de générer une erreur à partir d'un emplacement spécifique dans votre code.
9	#warning Il permet de générer un avertissement de niveau un à partir d'un emplacement spécifique de votre code.
dix	#region Il vous permet de spécifier un bloc de code que vous pouvez développer ou réduire lors de l'utilisation de la fonctionnalité de mise en plan de l'éditeur de code Visual Studio.
11	#endregion Il marque la fin d'un bloc #region.

Le préprocesseur #define

La directive de préprocesseur #define crée des constantes symboliques.

#define vous permet de définir un symbole tel que, en utilisant le symbole comme expression passée à la directive #if, l'expression prend la valeur true. Sa syntaxe est la suivante -

#define symbol

Le programme suivant illustre cela -

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

PI is defined

Directives conditionnelles

Vous pouvez utiliser la directive #if pour créer une directive conditionnelle. Les directives conditionnelles sont utiles pour tester un symbole ou des symboles afin de vérifier s'ils sont évalués à vrai. S'ils évaluent à vrai, le compilateur évalue tout le code entre le #if et la directive suivante.

La syntaxe de la directive conditionnelle est -

#if symbol [operator symbol]...

Où, symbole est le nom du symbole que vous souhaitez tester. Vous pouvez également utiliser true et false ou ajouter au début le symbole avec l'opérateur de négation.

Le symbole opérateur est l'opérateur utilisé pour évaluer le symbole. Les opérateurs peuvent être l'un des suivants:

• == (égalité)
• ! = (inégalité)
• && (et)
• || (ou)

Vous pouvez également regrouper des symboles et des opérateurs entre parenthèses. Les directives conditionnelles sont utilisées pour compiler du code pour une version de débogage ou lors de la compilation pour une configuration spécifique. Une directive conditionnelle commençant par un#if directive doit être explicitement terminée par un #endif directif.

Le programme suivant montre l'utilisation de directives conditionnelles -

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

DEBUG and VC_V10 are defined