C# - Directives du 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'espacement 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 faciliter 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# −

#définir

Il définit une séquence de caractères, appelée symbole.

#undef

Il vous permet d'indéfinir un symbole.

#si

Il permet de tester un ou plusieurs symboles pour voir s'ils sont évalués comme vrais.

#else

Il permet de créer une directive conditionnelle composée, avec #if.

#elif

Il permet de créer une directive conditionnelle composée.

#endif

Spécifie la fin d'une directive conditionnelle.

#ligne

Il vous permet de modifier le numéro de ligne du compilateur et (éventuellement) la sortie du nom de fichier pour les erreurs et les avertissements.

#erreur

Il permet de générer une erreur à partir d'un emplacement spécifique dans votre code.

#avertissement

Il permet de générer un avertissement de niveau un à partir d'un emplacement spécifique dans votre code.

#région

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 plan de l'éditeur de code de Visual Studio.

#endregion

Il marque la fin d'un bloc #region.

Sr.No.	Directive et description du préprocesseur
1
2
3
4
5
6
7
8
9
10
11

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 est évaluée à true. Sa syntaxe est la suivante −

#define symbol

Le programme suivant illustre cela −

Démo en direct

#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 ou plusieurs symboles afin de vérifier s'ils ont la valeur true. S'ils sont évalués à 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 voulez tester. Vous pouvez également utiliser vrai et faux ou faire précéder le symbole de l'opérateur de négation.

Le symbole de l'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 grouper des symboles et des opérateurs avec des 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 La directive doit explicitement se terminer par un #endif directives.

Le programme suivant illustre l'utilisation de directives conditionnelles −

Démo en direct

#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