In deze tutorial leren we over Preprocessor Directives, beschikbare richtlijnen in C # en wanneer, waarom en hoe ze worden gebruikt.
Zoals de naam rechtvaardigt, zijn preprocessorrichtlijnen een blok met instructies die worden verwerkt voordat de feitelijke compilatie begint. C # preprocessor-instructies zijn de opdrachten voor de compiler die van invloed zijn op het compilatieproces.
Deze commando's specificeren welke secties van de code moeten worden gecompileerd of hoe specifieke fouten en waarschuwingen moeten worden afgehandeld.
C # preprocessor-instructie begint met een # (hash)
symbool en alle preprocessor-instructies duren één regel. Preprocessor-richtlijnen worden new line
eerder beëindigd dan semicolon
.
De preprocessor-richtlijnen die beschikbaar zijn in C # zijn:
Preprocessor-richtlijnen in C #Preprocessor-richtlijn | Omschrijving | Syntaxis |
---|---|---|
#if | Controleert of een preprocessor-expressie waar is of niet |
#if preprocessor-expressiecode om #endif te compileren |
#elif | Wordt samen met #if gebruikt om meerdere preprocessor-expressies te controleren |
#if preprocessor-expression-1 code om #elif preprocessor-expression-2 code te compileren #endif |
#else | Wordt samen met #if gebruikt om samengestelde voorwaardelijke instructies te maken. |
#if preprocessor-expressiecode om #elif-code te compileren om #endif te compileren |
#endif | Wordt samen met #if gebruikt om het einde van een voorwaardelijke richtlijn aan te geven |
#if preprocessor-expressiecode om #endif te compileren |
#define | Wordt gebruikt om een symbool te definiëren |
# definiëren SYMBOOL |
#undef | Wordt gebruikt om een symbool te definiëren |
#undef SYMBOOL |
#warning | Hiermee kunnen we een waarschuwing van niveau 1 genereren vanuit onze code |
#waarschuwingsbericht |
#error | Hiermee kunnen we fouten genereren vanuit onze code |
#fout foutbericht |
#line | Hiermee kunnen we het regelnummer en de bestandsnaam van de compiler wijzigen om fouten en waarschuwingen weer te geven |
# regel regelnummer bestandsnaam |
#region | Hiermee kunnen we een regio maken die kan worden uitgevouwen of samengevouwen bij gebruik van een Visual Studio Code Editor |
#regio regiobeschrijvingscodes #endregion |
#endregion | Geeft het einde van een regio aan |
#regio regiobeschrijvingscodes #endregion |
#pragma | Geeft de compiler speciale instructies voor de compilatie van het bestand waarin het verschijnt. |
#pragma pragma-naam pragma-argumenten |
#define richtlijn
- De
#define
richtlijn stelt ons in staat om een symbool te definiëren. - Symbolen die zijn gedefinieerd wanneer ze samen met een
#if
richtlijn worden gebruikt , worden geëvalueerd als waar. - Deze symbolen kunnen worden gebruikt om voorwaarden voor compilatie te specificeren.
- Syntaxis:
# definiëren SYMBOOL
- Bijvoorbeeld:
# definiëren TESTEN
Hier is TESTEN een symbool.
#undef richtlijn
- De
#undef
richtlijn stelt ons in staat om een symbool te definiëren. - Ongedefinieerde symbolen die samen met de
#if
richtlijn worden gebruikt , zullen resulteren in onwaar. - Syntaxis:
#undef SYMBOOL
- Bijvoorbeeld:
#undef TESTEN
Hier is TESTEN een symbool.
#if richtlijn
- De
#if
instructie wordt gebruikt om de preprocessor-expressie te testen. - Een preprocessor-expressie kan alleen bestaan uit een symbool of een combinatie van symbolen samen met operatoren zoals
&&
(AND),||
(OR),!
(NOT). #if
richtlijn wordt gevolgd door een#endif
richtlijn.- De codes in de
#if
richtlijn worden alleen gecompileerd als de uitdrukking die wordt getest met#if
waar is. - Syntaxis:
#if preprocessor-expressiecode om <#endif
- Bijvoorbeeld:
#if TESTING Console.WriteLine ("Momenteel aan het testen"); #stop als
Voorbeeld 1: Hoe de #if-richtlijn te gebruiken?
#define CSHARP using System; namespace Directive ( class ConditionalDirective ( public static void Main(string() args) ( #if (CSHARP) Console.WriteLine("CSHARP is defined"); #endif ) ) )
Wanneer we het programma uitvoeren, is de uitvoer:
CSHARP is defined
In the above program, CSHARP
symbol is defined using the #define
directive at the beginning of program. Inside the Main()
method, #if
directive is used to test whether CSHARP
is true or not. The block of code inside #if
directive is compiled only if CSHARP
is defined.
#elif directive
- The
#elif
directive is used along with #if directive that lets us create a compound conditional directive. - It is used when testing multiple preprocessor expression.
- The codes inside the
#elif
directive is compiled only if the expression tested with that#elif
evaluates to true. - Syntax:
#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code-to-compile #endif
- For example:
#if TESTING Console.WriteLine("Currently Testing"); #elif TRAINING Console.WriteLine("Currently Training"); #endif
#else directive
- The
#else
directive is used along with#if
directive. - If none of the expression in the preceding
#if
and#elif
(if present) directives are true, the codes inside the#else
directive will be compiled. - Syntax:
#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code-to-compile #else code-to-compile #endif
- For example:
#if TESTING Console.WriteLine("Currently Testing"); #elif TRAINING Console.WriteLine("Currently Training"); #else Console.WriteLine("Neither Testing nor Training"); #endif
#endif directive
- The
#endif
directive is used along with#if
directive to indicate the end of#if
directive. - Syntax:
#if preprocessor-expression-1 code to compile #endif
- For example:
#if TESTING Console.WriteLine("Currently Testing"); #endif
Example 2: How to use conditional directive (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 ) ) )
When we run the program, the output will be:
CSHARP is defined, PYTHON is undefined
In this example, we can see the use of #elif
and #else
directive. These directive are used when there are multiple conditions to be tested. Also, symbols can be combined using logical operators to form a preprocessor expression.
#warning directive
- The
#warning
directive allows us to generate a user-defined level one warning from our code. - Syntax:
#warning warning-message
- For example:
#warning This is a warning message
Example 3: How to use #warning directive?
using System; namespace Directives ( class WarningDirective ( public static void Main(string() args) ( #if (!CSHARP) #warning CSHARP is undefined #endif Console.WriteLine("#warning directive example"); ) ) )
When we run the program, the output will be:
Program.cs(10,26): warning CS1030: #warning: 'CSHARP is undefined' (/home/myuser/csharp/directives-project/directives-project.csproj) #warning directive example
After running the above program, we will see the output as above. The text represents a warning message. Here, we are generating a user-defined warning message using the #warning
directive.
Note that the statements after the #warning
directive are also executed. It means that the #warning
directive does not terminate the program but just throws a warning.
#error directive
- The
#error
directive allows us to generate a user-defined error from our code. - Syntax:
#error error-message
- For example:
#error This is an error message
Example 4: How to use #error directive?
using System; namespace Directive ( class Error ( public static void Main(string() args) ( #if (!CSHARP) #error CSHARP is undefined #endif Console.WriteLine("#error directive example"); ) ) )
When we run the program, the output will be:
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.
We will see some errors, probably like above. Here we are generating a user-defined error.
Another thing to note here is the program will be terminated and the line #error directive example
won't be printed as it was in the #warning
directive.
#line directive
- The
#line
directive allows us to modify the line number and the filename for errors and warnings. - Syntax:
#line line-number file-name
- For example:
#line 50 "fakeprogram.cs"
Example 5: How to use #line directive?
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 ) ) )
When we run the program, the output will be:
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)
We have saved the above example as Program.cs
. The warning was actually generated at line 10
by Program.cs
. Using the #line
directive, we have changed the line number to 200
and the filename to AnotherProgram.cs
that generated the error.
#region and #endregion directive
- The
#region
directive allows us to create a region that can be expanded or collapsed when using a Visual Studio Code Editor. - This directive is simply used to organize the code.
- The #region block can not overlap with a
#if
block. However, a#region
block can be included within a#if
block and a#if
block can overlap with a#region
block. #endregion
directive indicates the end of a#region
block.- Syntax:
#region region-description codes #endregion
Example 6: How to use #region directive?
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 ) ) )
When we run the program, the output will be:
Hello Hello Hello Hello Hello
#pragma directive
- The
#pragma
directive is used to give the compiler some special instructions for the compilation of the file in which it appears. - The instruction may include disabling or enabling some warnings.
- C# supports two
#pragma
instructions:#pragma warning
: Used for disabling or enabling warnings#pragma checksum
: It generates checksums for source files which will be used for debugging.
- Syntax:
#pragma pragma-naam pragma-argumenten
- Bijvoorbeeld:
#pragma waarschuwing uitschakelen
Voorbeeld 7: Hoe de #pragma-richtlijn te gebruiken?
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 ) ) )
Wanneer we het programma uitvoeren, is de uitvoer:
Program.cs (12,22): waarschuwing CS1030: #warning: 'Dit is een waarschuwing 2' (/home/myuser/csharp/directive-project/directive-project.csproj)
We kunnen zien dat alleen de tweede waarschuwing wordt weergegeven op het uitvoerscherm.
Dit komt omdat we in eerste instantie alle waarschuwingen vóór de eerste waarschuwing hebben uitgeschakeld en ze pas vóór de tweede waarschuwing hebben hersteld. Dit is de reden waarom de eerste waarschuwing verborgen was.
We kunnen ook specifieke waarschuwingen uitschakelen in plaats van alle waarschuwingen.
Voor meer informatie over #pragma
, bezoek #pragma (C # referentie).