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 #. Et sur une ligne, seuls les espaces peuvent apparaître avant les directives du préprocesseur. 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# :
| 预处理器指令 | 描述 |
|---|---|
| #define | 它用于定义一系列成为符号的字符。 |
| #undef | 它用于取消定义符号。 |
| #if | 它用于测试符号是否为真。 |
| #else | 它用于创建复合条件指令，与 #if 一起使用。 |
| #elif | 它用于创建复合条件指令。 |
| #endif | 指定一个条件指令的结束。 |
| #line | 它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。 |
| #error | 它允许从代码的指定位置生成一个错误。 |
| #warning | 它允许从代码的指定位置生成一级警告。 |
| #region | 它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。 |
| #endregion | 它标识着 #region 块的结束。 |
#define preprocessor
La directive #define preprocessor 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.
Syntaxe de la directive conditionnelle :
#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.
Le symbole de l'opérateur est un opérateur utilisé 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 combiner des symboles et des opérateurs Faites des groupes. 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
