Maîtriser les directives de préprocesseur C# : Guide pratique

Maîtriser les directives de préprocesseur C#

Découvrez comment les directives de préprocesseur C# influencent la compilation, contrôlent le flux et gèrent les erreurs. Ce guide couvre chaque directive, sa syntaxe, des exemples réels et les bonnes pratiques.

Les directives de préprocesseur sont des commandes que le compilateur évalue avant le début de la compilation réelle. Elles dictent quelles sections de code sont incluses, comment les avertissements et erreurs sont gérés, et peuvent même modifier la vision du compilateur sur les numéros de ligne et noms de fichiers.

En C#, une directive commence par un symbole # et s'étend sur une seule ligne, terminée par un saut de ligne plutôt que par un point-virgule.

#if expression code #endif

#if expr1 code1 #elif expr2 code2 #endif

#if expr1 code1 #else code2 #endif

#if expr code #endif

#define SYMBOLE

#undef SYMBOLE

#warning Votre message d'avertissement

#error Votre message d'erreur

#line 50 "FakeProgram.cs" #endif

#region Description code #endregion

#pragma warning disable #endif

Définition et suppression de symboles

• #define crée un symbole qui évalue à true dans les blocs #if.
• #undef supprime un symbole, le faisant évaluer à false.

Exemple : Définition d'un symbole

#define TESTS

Exemple : Suppression d'un symbole

#undef TESTS

Compilation conditionnelle avec #if, #elif, #else et #endif

• #if teste une expression ; le code à l'intérieur est compilé seulement si l'expression est vraie.
• Les expressions peuvent utiliser des opérateurs logiques (&&, ||, !) et des symboles.
• #elif permet de tester plusieurs conditions séquentiellement.
• #else s'exécute quand aucune des conditions précédentes n'est satisfaite.
• #endif termine le bloc conditionnel.

Exemple pratique

#define CSHARP
#undef PYTHON
using System;
namespace Directive {
    class DirectiveConditionnelle {
        static void Main(string[] args) {
            #if (CSHARP && PYTHON)
                Console.WriteLine("CSHARP et PYTHON sont définis");
            #elif (CSHARP && !PYTHON)
                Console.WriteLine("CSHARP est défini, PYTHON est indéfini");
            #elif (!CSHARP && PYTHON)
                Console.WriteLine("PYTHON est défini, CSHARP est indéfini");
            #else
                Console.WriteLine("CSHARP et PYTHON sont indéfinis");
            #endif
        }
    }
}

Sortie : CSHARP est défini, PYTHON est indéfini

Génération d'avertissements et d'erreurs

• #warning émet un avertissement compilateur défini par l'utilisateur mais permet au programme de continuer.
• #error émet une erreur fatale, arrêtant la compilation.

Exemple d'avertissement

using System;
namespace Directives {
    class DirectiveAvertissement {
        public static void Main(string[] args) {
            #if (!CSHARP)
                #warning CSHARP est indéfini
            #endif
            Console.WriteLine("Exemple de directive #warning");
        }
    }
}

La sortie inclut une ligne d'avertissement mais le texte de la console s'affiche.

Exemple d'erreur

using System;
namespace Directive {
    class Erreur {
        public static void Main(string[] args) {
            #if (!CSHARP)
                #error CSHARP est indéfini
            #endif
            Console.WriteLine("Exemple de directive #error");
        }
    }
}

Sortie : la compilation échoue avec une erreur à la compilation ; la dernière ligne de console n'est jamais exécutée.

Personnalisation des emplacements de diagnostic avec #line

• Modifie le numéro de ligne et le nom de fichier rapportés pour les avertissements ou erreurs subséquents.

Exemple

using System;
namespace Directive {
    class DemoLigne {
        public static void Main(string[] args) {
            #line 200 "AutreProgramme.cs"
            #warning Avertissement réel généré par Program.cs à la ligne 10
        }
    }
}

Résultat : L'avertissement apparaît comme AutreProgramme.cs(200,22): warning CS1030: ...

Organisation du code avec #region et #endregion

• Regroupe des blocs de code liés, qui peuvent être pliés dans les éditeurs.
• Ne peut pas chevaucher un autre #region, mais peut résider dans un bloc conditionnel.

Exemple

using System;
namespace Directive {
    class DemoRegion {
        public static void Main(string[] args) {
            #region Bonjour
                Console.WriteLine("Bonjour");
                Console.WriteLine("Bonjour");
                Console.WriteLine("Bonjour");
                Console.WriteLine("Bonjour");
                Console.WriteLine("Bonjour");
            #endregion
        }
    }
}

Sortie : cinq lignes de "Bonjour".

Instructions avancées au compilateur avec #pragma

• Permet un contrôle fin du comportement du compilateur.
• Usages courants :
  • #pragma warning disable – désactive tous les avertissements.
  • #pragma warning restore – réactive les avertissements.
  • Des numéros d'avertissement spécifiques peuvent être ciblés (ex. #pragma warning disable CS0168).
  • #pragma checksum – génère des sommes de contrôle pour le débogage.

Exemple

using System;
namespace Directive {
    class DemoPragma {
        public static void Main(string[] args) {
            #pragma warning disable
            #warning Ceci est un avertissement 1
            #pragma warning restore
            #warning Ceci est un avertissement 2
        }
    }
}

Seul le second avertissement est affiché.

Pour plus de détails, consultez la référence officielle #pragma (référence C#).