C # förprocessordirektiv

I den här handledningen lär vi oss om Preprocessor Directives, tillgängliga direktiv i C #, och när, varför och hur varför de används.

Som namnet motiverar är förprocessordirektiv ett block av uttalanden som bearbetas innan själva sammanställningen startar. C # förprocessordirektiv är kommandona för kompilatorn som påverkar kompileringsprocessen.

Dessa kommandon anger vilka delar av koden som ska kompileras eller hur man hanterar specifika fel och varningar.

C # förprocessordirektiv börjar med en # (hash)symbol och alla förprocessordirektiv håller i en rad. Direktiven om förprocessorer avslutas av new linesnarare än semicolon.

De förprocessordirektiv som finns i C # är:

Förprocessordirektiv i C #
Förprocessordirektivet Beskrivning Syntax
#if Kontrollerar om ett förprocessoruttryck är sant eller inte 
 #if förprocessor-expressionskod för att kompilera #endif
#elif Används tillsammans med för #ifatt kontrollera flera förprocessoruttryck 
 #if preprocessor-expression-1-kod för att kompilera #elif preprocessor-expression-2-kod för att kompilera #endif
#else Används tillsammans med för #ifatt skapa sammansatt villkorligt direktiv. 
 #if förprocessor-expressionskod för att kompilera #elif-kod för att kompilera #endif
#endif Används tillsammans med för #ifatt ange slutet på ett villkorligt direktiv 
 #if förprocessor-expressionskod för att kompilera #endif
#define Används för att definiera en symbol 
 #define SYMBOL
#undef Används för att odefiniera en symbol 
 #undef SYMBOL
#warning Låter oss generera nivå 1-varning från vår kod 
 #varningsvarningsmeddelande
#error Låter oss generera fel från vår kod 
 #error felmeddelande
#line Låter oss ändra kompilatorns radnummer och filnamn för att visa fel och varningar 
 #line radnummer filnamn
#region Låter oss skapa en region som kan expanderas eller kollapsas när vi använder en Visual Studio Code Editor 
 #region regionbeskrivningskoder #endregion
#endregion Indikerar slutet på en region 
 #region regionbeskrivningskoder #endregion
#pragma Ger kompilatorn speciella instruktioner för sammanställning av filen där den visas. 
 #pragma pragma-namn pragma-argument

#definiera direktiv

  • Det #definedirektivet tillåter oss att definiera en symbol.
  • Symboler som definieras när de används tillsammans med #ifdirektivet kommer att utvärderas till sant.
  • Dessa symboler kan användas för att ange villkor för sammanställning.
  • Syntax: 
     #define SYMBOL
  • Till exempel: 
     #define TESTING
    Här är TESTING en symbol.

#undef-direktivet

  • Det #undefdirektivet ger oss möjlighet att odefiniera en symbol.
  • Odefinierade symboler när de används tillsammans med #ifdirektivet utvärderas till falska.
  • Syntax: 
     #undef SYMBOL
  • Till exempel: 
     #undef TESTING
    Här är TESTING en symbol.

# om direktiv

  • Det #ifdirektivet används för att testa preprocessoruttryck.
  • Ett preprocessoruttryck kan bestå av endast en symbol eller en kombination av symboler tillsammans med operatorer som &&(AND), ||(OR), !(NOT).
  • #ifdirektivet följs av ett #endifdirektiv.
  • Koderna i #ifdirektivet sammanställs endast om det uttryck som testats med #ifutvärderas till sant.
  • Syntax: 
     #if förprocessor-expressionskod för att kompilera <#endif
  • Till exempel: 
    #if TESTING Console.WriteLine ("Testar för närvarande"); #endif

Exempel 1: Hur använder jag #if-direktivet?

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

När vi kör programmet blir resultatet:

 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-namn pragma-argument
  • Till exempel: 
     #pragma varning inaktivera

Exempel 7: Hur använder jag #pragma-direktivet?

 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 ) ) )

När vi kör programmet blir resultatet:

 Program.cs (12,22): varning CS1030: #varning: 'Detta är en varning 2' (/home/myuser/csharp/directive-project/directive-project.csproj)

Vi kan se att endast den andra varningen visas på utskärmen.

Detta beror på att vi ursprungligen inaktiverade alla varningar före den första varningen och återställde dem bara före den andra varningen. Detta är anledningen till att den första varningen doldes.

Vi kan också inaktivera specifik varning istället för all varning.

För att lära dig mer om #pragma, besök #pragma (C # referens).

Intressanta artiklar...