[Tutoriel C#] Directives du préprocesseur C#

Directives du préprocesseur C#

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

Toutes les directives du préprocesseur commencent par #. Seuls les caractères d'espacement peuvent apparaître avant les directives du 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 instructions sont traitées comme s'il existait un préprocesseur séparé. En C#, les directives du préprocesseur sont utilisées pour fonctionner en 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 directive sur la ligne.

Liste des directives du préprocesseur C#

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

Directives du préprocesseur

Description

#define Il est utilisé pour définir une série de caractères qui deviennent des symboles.

#undef Il est utilisé pour dédéfinir un symbole.

#if Il est utilisé pour tester si le symbole est vrai.

#else Il est utilisé pour créer des instructions conditionnelles composées, utilisées avec #if.

#elif Il est utilisé pour créer des instructions conditionnelles composées.

#endif Spécifie la fin d'une instruction conditionnelle.

#line Il vous permet de modifier le nombre de lignes utilisées par le compilateur et (éventuellement) les noms de fichiers où les erreurs et les avertissements sont générés.

#error Permet de générer une erreur à partir d'un emplacement spécifié dans le code.

#warning Il permet de générer un avertissement de premier niveau à partir d'un emplacement spécifié dans le code.

#region Il vous permet de spécifier un bloc de code extensible ou réduit lors de l'utilisation de la fonctionnalité Outline de Visual Studio Code Editor.

#endregion Cela marque la fin du bloc #region.

#define préprocesseur

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

#define vous permet de définir un symbole tel que, en utilisant le symbole comme expression passée à une directive #if, l'expression retournera vrai. Sa syntaxe est la suivante :

#define symbol

Le programme suivant illustre ceci :

#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 les résultats suivants :

PI is defined

Directives conditionnelles

Vous pouvez utiliser la directive #if pour créer une directive conditionnelle. Les instructions conditionnelles sont utilisées pour tester si un symbole est vrai. Si c'est vrai, le compilateur exécute le code entre #if et l'instruction suivante.

La syntaxe des instructions conditionnelles :

#if symbol [operator symbol]...

où symbole est le nom du symbole à tester. Vous pouvez également utiliser vrai et faux, ou placer l'opérateur de négation avant le symbole. Les symboles d'opérateur

sont des opérateurs utilisés pour évaluer les symboles. L'opérateur de canette peut être l'un des opérateurs suivants :

== (égalité)

!= (inégalité)

&& (et)

| | (ou)

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

Le programme suivant dé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 les résultats suivants :

DEBUG and VC_V10 are defined

Ce qui précède est le contenu du [tutoriel c#] instructions du préprocesseur C# Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !