Directives du préprocesseur C#

Dans ce didacticiel, nous découvrirons les directives de préprocesseur, les directives disponibles en C#, et quand, pourquoi et comment elles sont utilisées.

Comme son nom l'indique, les directives du préprocesseur sont un bloc d'instructions qui est traité avant le début de la compilation proprement dite. Les directives du préprocesseur C# sont les commandes du compilateur qui affectent le processus de compilation.

Ces commandes spécifient les sections du code à compiler ou comment gérer des erreurs et des avertissements spécifiques.

La directive du préprocesseur C# commence par un # (hash) symbole et toutes les directives du préprocesseur durent une ligne. Les directives du préprocesseur se terminent par new line plutôt que semicolon .

Les directives de préprocesseur disponibles en C# sont :

Directives de préprocesseur en C#
Directive du préprocesseur	Description	Syntaxe
`#if`	Vérifie si une expression de préprocesseur est vraie ou non	#if preprocessor-expression code to compile #endif
`#elif`	Utilisé avec `#if` pour vérifier plusieurs expressions de préprocesseur	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Utilisé avec `#if` pour créer une directive conditionnelle composée.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Utilisé avec `#if` pour indiquer la fin d'une instruction conditionnelle	#if preprocessor-expression code to compile #endif
`#define`	Utilisé pour définir un symbole	#define SYMBOL
`#undef`	Utilisé pour indéfinir un symbole	#undef SYMBOL
`#warning`	Nous permet de générer un avertissement de niveau 1 à partir de notre code	#warning warning-message
`#error`	Nous permet de générer une erreur à partir de notre code	#error error-message
`#line`	Nous permet de modifier le numéro de ligne et le nom de fichier du compilateur pour afficher les erreurs et les avertissements	#line line-number file-name
`#region`	Nous permet de créer une région qui peut être développée ou réduite lors de l'utilisation d'un éditeur de code Visual Studio	#region region-description codes #endregion
`#endregion`	Indique la fin d'une région	#region region-description codes #endregion
`#pragma`	Donne au compilateur des instructions spéciales pour la compilation du fichier dans lequel il apparaît.	#pragma pragma-name pragma-arguments

#définir la directive

Le #define directive nous permet de définir un symbole.
Symboles définis lorsqu'ils sont utilisés avec #if directive sera évaluée à true.
Ces symboles peuvent être utilisés pour spécifier les conditions de compilation.
Syntaxe :
```
#define SYMBOL
```
Par exemple :
```
#define TESTING
```
Ici, TESTER est un symbole.

Directive #undef

Le #undef directive nous permet d'indéfinir un symbole.
Symboles non définis lorsqu'ils sont utilisés avec #if directive sera évaluée comme fausse.
Syntaxe :
```
#undef SYMBOL
```
Par exemple :
```
#undef TESTING
```
Ici, TESTER est un symbole.

Directive #if

Le #if sont utilisées pour tester l'expression du préprocesseur.
Une expression de préprocesseur peut se composer d'un symbole uniquement ou d'une combinaison de symboles avec des opérateurs tels que && (ET), || (OU), ! (PAS).
#if est suivie d'un #endif directive.
Les codes à l'intérieur du #if directive n'est compilée que si l'expression est testée avec #if est évalué à vrai.

Syntaxe :

#if preprocessor-expression
	code to compile<
#endif

Par exemple :

#if TESTING
	Console.WriteLine("Currently Testing");
#endif

Exemple 1 :Comment utiliser la directive #if ?

#define CSHARP

using System;
 
namespace Directive
{
	class ConditionalDirective
	{
		public static void Main(string[] args)
		{
			#if (CSHARP)
				Console.WriteLine("CSHARP is defined");
			#endif
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

CSHARP is defined

Dans le programme ci-dessus, CSHARP le symbole est défini en utilisant le #define directive au début du programme. À l'intérieur du Main() méthode, #if est utilisée pour tester si CSHARP est vrai ou non. Le bloc de code à l'intérieur de #if directive est compilée uniquement si CSHARP est défini.

Instruction #elif

Le #elif est utilisée avec la directive #if qui nous permet de créer une directive conditionnelle composée.
Il est utilisé lors du test de plusieurs expressions de préprocesseur.
Les codes à l'intérieur du #elif directive est compilée uniquement si l'expression testée avec ce #elif est évalué à vrai.

Syntaxe :

#if preprocessor-expression-1
	code to compile
#elif preprocessor-expression-2
	code-to-compile
#endif

Par exemple :

#if TESTING
	Console.WriteLine("Currently Testing");
#elif TRAINING
	Console.WriteLine("Currently Training");
#endif

Instruction #else

Le #else directive est utilisée avec #if directive.
Si aucune des expressions dans le #if précédent et #elif (le cas échéant) les directives sont vraies, les codes à l'intérieur du #else sera compilée.

Syntaxe :

#if preprocessor-expression-1
	code to compile
#elif preprocessor-expression-2
	code-to-compile
#else
	code-to-compile
#endif

Par exemple :

#if TESTING
	Console.WriteLine("Currently Testing");
#elif TRAINING
	Console.WriteLine("Currently Training");
#else
	Console.WriteLine("Neither Testing nor Training");
#endif

Instruction #endif

Le #endif directive est utilisée avec #if directive pour indiquer la fin de #if directive.

Syntaxe :

#if preprocessor-expression-1
	code to compile
#endif

Par exemple :

#if TESTING
	Console.WriteLine("Currently Testing");
#endif

Exemple 2 :Comment utiliser la directive conditionnelle (if, elif, else, endif) ?

#define CSHARP
#undef PYTHON
 
using System;
 
namespace Directive
{
	class ConditionalDirective
	{
		static void Main(string[] args)
		{
			#if (CSHARP && PYTHON)
				Console.WriteLine("CSHARP and PYTHON are defined");
			#elif (CSHARP && !PYTHON)
				Console.WriteLine("CSHARP is defined, PYTHON is undefined");
			#elif (!CSHARP && PYTHON)
				Console.WriteLine("PYTHON is defined, CSHARP is undefined");
			#else
				Console.WriteLine("CSHARP and PYTHON are undefined");
			#endif
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

CSHARP is defined, PYTHON is undefined

Dans cet exemple, nous pouvons voir l'utilisation de #elif et #else directif. Ces directives sont utilisées lorsqu'il y a plusieurs conditions à tester. De plus, les symboles peuvent être combinés à l'aide d'opérateurs logiques pour former une expression de préprocesseur.

#instruction d'avertissement

Le #warning nous permet de générer un avertissement de niveau un défini par l'utilisateur à partir de notre code.
Syntaxe :
```
#warning warning-message
```
Par exemple :
```
#warning This is a warning message
```

Exemple 3 :Comment utiliser la directive #warning ?

using System;
 
namespace Directives
{
	class WarningDirective
	{
		public static void Main(string[] args)
		{
			#if (!CSHARP)
				#warning CSHARP is undefined
			#endif
			Console.WriteLine("#warning directive example");
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Program.cs(10,26): warning CS1030: #warning: 'CSHARP is undefined' [/home/myuser/csharp/directives-project/directives-project.csproj]
#warning directive example

Après avoir exécuté le programme ci-dessus, nous verrons la sortie comme ci-dessus. Le texte représente un message d'avertissement. Ici, nous générons un message d'avertissement défini par l'utilisateur en utilisant le #warning directives.

Notez que les instructions après le #warning directive sont également exécutées. Cela signifie que le #warning ne met pas fin au programme, mais envoie simplement un avertissement.

#instruction d'erreur

Le #error nous permet de générer une erreur définie par l'utilisateur à partir de notre code.
Syntaxe :
```
#error error-message
```
Par exemple :
```
#error This is an error message
```

Exemple 4 :Comment utiliser la directive #error ?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#if (!CSHARP)
				#error CSHARP is undefined
			#endif
			Console.WriteLine("#error directive example");
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Program.cs(10,24): error CS1029: #error: 'CSHARP is undefined' [/home/myuser/csharp/directives-project/directives-project.csproj]
The build failed. Please fix the build errors and run again.

Nous verrons quelques erreurs, probablement comme ci-dessus. Ici, nous générons une erreur définie par l'utilisateur.

Une autre chose à noter ici est que le programme sera terminé et la ligne #error directive example ne sera pas imprimé comme il l'était dans le #warning directives.

Instruction #line

Le #line nous permet de modifier le numéro de ligne et le nom du fichier pour les erreurs et les avertissements.
Syntaxe :
```
#line line-number file-name
```
Par exemple :
```
#line 50 "fakeprogram.cs"
```

Exemple 5 :Comment utiliser la directive #line ?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#line 200 "AnotherProgram.cs"
			#warning Actual Warning generated by Program.cs on line 10
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

AnotherProgram.cs(200,22): warning CS1030: #warning: 'Actual Warning generated by Program.cs on line 10' [/home/myuser/csh
arp/directive-project/directive-project.csproj]

Nous avons enregistré l'exemple ci-dessus sous le nom Program.cs . L'avertissement a en fait été généré à line 10 par Program.cs . Utilisation du #line directive, nous avons changé le numéro de ligne en 200 et le nom du fichier en AnotherProgram.cs qui a généré l'erreur.

Instruction #region et #endregion

Le #region nous permet de créer une région qui peut être développée ou réduite lors de l'utilisation d'un éditeur de code Visual Studio.
Cette directive est simplement utilisée pour organiser le code.
Le bloc #region ne peut pas chevaucher un #if bloquer. Cependant, un #region le bloc peut être inclus dans un #if bloc et un #if le bloc peut chevaucher un #region bloquer.
#endregion indique la fin d'un #region bloquer.

Syntaxe :

#region region-description
	codes
#endregion

Exemple 6 :Comment utiliser la directive #region ?

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

Lorsque nous exécutons le programme, la sortie sera :

Hello
Hello
Hello
Hello
Hello

Directive #pragma

Le #pragma est utilisée pour donner au compilateur des instructions spéciales pour la compilation du fichier dans lequel elle apparaît.
L'instruction peut inclure la désactivation ou l'activation de certains avertissements.
C# prend en charge deux #pragma instructions :
- #pragma warning :Utilisé pour désactiver ou activer les avertissements
- #pragma checksum :Il génère des sommes de contrôle pour les fichiers source qui seront utilisés pour le débogage.
Syntaxe :
```
#pragma pragma-name pragma-arguments
```
Par exemple :
```
#pragma warning disable
```

Exemple 7 :Comment utiliser la directive #pragma ?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#pragma warning disable
			#warning This is a warning 1
			#pragma warning restore
			#warning This is a warning 2
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Program.cs(12,22): warning CS1030: #warning: 'This is a warning 2' [/home/myuser/csharp/directive-project/directive-project.csproj]

Nous pouvons voir que seul le deuxième avertissement s'affiche sur l'écran de sortie.

En effet, nous avons initialement désactivé tous les avertissements avant le premier avertissement et les avons restaurés uniquement avant le deuxième avertissement. C'est la raison pour laquelle le premier avertissement a été masqué.

Nous pouvons également désactiver un avertissement spécifique au lieu de tous les avertissements.

Pour en savoir plus sur #pragma , visitez #pragma (référence C#).

Conversion de types C# Espaces de noms dans la programmation C#

Langue C