C# Directives de préprocesseur

Les directives de préprocesseur indiquent au compilateur de prétraiter les informations avant que la compilation proprement dite ne commence.

Grâce à ces directives, vous pouvez contrôler la façon dont le compilateur compile les fichiers ou les parties à compiler. Les directives de préprocesseur courantes incluent la compilation conditionnelle, les définitions de macros, etc.

Toutes les directives de préprocesseur commencent par#Elles commencent par #, et sur une même ligne, seuls des caractères d'espacement peuvent apparaître avant une directive de préprocesseur.

Les directives de préprocesseur ne sont pas des instructions, donc elles ne se terminent pas par un point-virgule.;fin.

Le compilateur C# n'a pas de préprocesseur séparé ; toutefois, les directives sont traitées comme s'il en existait un. En C#, les directives de préprocesseur sont utilisées pour la compilation conditionnelle. Contrairement à C et C++, elles ne servent pas à créer des macros. Une directive de préprocesseur doit être la seule directive sur cette ligne.

Liste des directives de préprocesseur C#

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

DirectiveDescription
#defineDéfinir un symbole pouvant être utilisé pour la compilation conditionnelle.
#undefAnnuler la définition d’un symbole.
#ifCommencer un bloc de compilation conditionnelle ; inclure le bloc de code si le symbole est défini.
#elifSi la précédente#ifou#elifSi la condition précédente n’est pas satisfaite et que la condition actuelle est satisfaite, inclure le bloc de code.
#elseSi la précédente#ifou#elifSi la condition n’est pas satisfaite, inclure le bloc de code.
#endifTerminer un bloc de compilation conditionnelle.
#warningGénérer un message d’avertissement du compilateur.
#errorGénérer un message d’erreur du compilateur.
#regionMarquer une région de code pouvant être réduite et développée dans l’IDE, ce qui facilite l’organisation et la lecture du code.
#endregionTerminer une région de code.
#lineModifier le numéro de ligne et le nom de fichier dans la sortie du compilateur, ce qui peut être utilisé pour le débogage ou pour le code généré par des outils.
#pragmaUtilisé pour envoyer des instructions spéciales au compilateur, telles que la désactivation ou la restauration d'avertissements spécifiques.
#nullableContrôler le contexte nullable et les annotations, permettant d'activer ou de désactiver les vérifications du compilateur pour les types de référence nullables.

Exemple

#define DEBUG

#if DEBUG
    Console.WriteLine("Debug mode");
#elif RELEASE
    Console.WriteLine("Release mode");
#else
    Console.WriteLine("Other mode");
#endif

#warning Ceci est un message d'avertissement
#error Ceci est un message d'erreur

#region MyRegion
    // Votre code ici
#endregion

#line 100 "MyFile.cs"
    // La ligne suivante sera signalée comme la ligne 100 dans MyFile.cs
    Console.WriteLine("This is line 100");
#line default
    // La numérotation des lignes revient à la normale

#pragma warning disable 414
    private int unusedVariable;
#pragma warning restore 414

#nullable enable
    string? nullableString = null;
#nullable disable

#define et #undef Préprocesseur

#defineSert à définir un symbole (généralement pour la compilation conditionnelle),#undefSert à annuler la définition d’un symbole.

#define DEBUG

#undef RELEASE

#define vous permet de définir un symbole afin que, en utilisant le symbole comme expression passée à la directive #if, l’expression retourne true. Sa syntaxe est la suivante :

#define symbol

Le programme suivant illustre ceci :

Exemple

#define PI
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine("PI est défini");
         #else
            Console.WriteLine("PI n'est pas défini");
         #endif
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

PI is defined

Directives conditionnelles : #if, #elif, #else et #endif

Vous pouvez utiliser#ifdirective pour créer une directive conditionnelle.

Les directives conditionnelles servent à tester si un symbole est true. Si c'est le cas, le compilateur exécutera#ifle code entre cette directive et la suivante.

Syntaxe des directives conditionnelles :

#if symbol [operator symbol]...

où,symbolele nom du symbole à tester. Vous pouvez également utiliser true et false, ou placer un opérateur de négation avant le symbole.

Les opérateurs courants incluent :

  • == (égal à)
  • != (différent de)
  • && (ET)
  • || (OU)

Vous pouvez également utiliser des parenthèses pour regrouper des symboles et des opérateurs. Les directives conditionnelles sont utilisées pour compiler du code dans les builds de débogage ou lors de la compilation d’une configuration spécifiée. Une directive conditionnelle qui commence par une#ifdirective doit se terminer explicitement par une#endifInstruction terminée.

#define DEBUG

#if DEBUG
    Console.WriteLine("Debug mode");
#elif RELEASE
    Console.WriteLine("Release mode");
#else
    Console.WriteLine("Other mode");
#endif

Le programme suivant démontre l’utilisation des directives conditionnelles :

Exemple

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
   public static void Main()
   {

      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG est défini");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 est défini");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG et VC_V10 sont définis");
      #else
         Console.WriteLine("DEBUG et VC_V10 ne sont pas définis");
      #endif
      Console.ReadKey();
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

DEBUG and VC_V10 are defined

#warning et #error

#warning est utilisé pour générer des avertissements du compilateur, et #error est utilisé pour générer des erreurs du compilateur.

#warning This is a warning message
#error This is an error message

#region et #endregion

Utilisé pour le pliage de code, ce qui rend le code plus lisible.

#region MyRegion
    // Your code here
#endregion

#line

Utilisé pour modifier le numéro de ligne et le nom de fichier dans la sortie du compilateur.

#line 100 "MyFile.cs"
    // The next line will be reported as line 100 in MyFile.cs
    Console.WriteLine("This is line 100");
#line default
    // Line numbering returns to normal

#pragma

Utilisé pour envoyer des instructions spéciales au compilateur. L'utilisation la plus courante consiste à désactiver des avertissements spécifiques.

#pragma warning disable 414
    private int unusedVariable;
#pragma warning restore 414

Remarques sur l'utilisation des directives de préprocesseur

  • Améliorer la lisibilité du code: Utilisez#regionPeut aider à séparer les blocs de code et à améliorer l'organisation du code.
  • Compilation conditionnelle: via#ifDe telles directives peuvent compiler un code différent dans les environnements de développement et de production, ce qui facilite le débogage et la publication.
  • Avertissements et erreurs: via#warninget#errorIls peuvent inciter les développeurs à prêter attention à des problèmes spécifiques au moment de la compilation.

En utilisant correctement ces directives de préprocesseur, vous pouvez mieux contrôler le processus de compilation du code et améliorer la flexibilité et la maintenabilité du code.

autres extensions