C# Preprocessor-richtlijnen

In deze zelfstudie leren we over Preprocessor-richtlijnen, beschikbare richtlijnen in C# en wanneer, waarom en hoe waarom ze worden gebruikt.

Zoals de naam rechtvaardigt, zijn preprocessor-richtlijnen een blok met instructies die worden verwerkt voordat de eigenlijke compilatie begint. C# preprocessor-richtlijnen zijn de opdrachten voor de compiler die het compilatieproces beïnvloeden.

Deze commando's specificeren welke secties van de code moeten worden gecompileerd of hoe specifieke fouten en waarschuwingen moeten worden afgehandeld.

C# preprocessor-richtlijn begint met een # (hash) symbool en alle preprocessor-richtlijnen duren één regel. Preprocessor-richtlijnen worden beëindigd door new line in plaats van semicolon .

De preprocessor-richtlijnen die beschikbaar zijn in C# zijn:

Preprocessor-richtlijnen in C#
Preprocessor-richtlijn	Beschrijving	Syntaxis
`#if`	Controleert of een preprocessor-expressie waar is of niet	#if preprocessor-expression code to compile #endif
`#elif`	Gebruikt samen met `#if` meerdere preprocessor-expressies controleren	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Gebruikt samen met `#if` om een samengestelde voorwaardelijke richtlijn te maken.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Gebruikt samen met `#if` om het einde van een voorwaardelijke richtlijn aan te geven	#if preprocessor-expression code to compile #endif
`#define`	Gebruikt om een symbool te definiëren	#define SYMBOL
`#undef`	Gebruikt om een symbool ongedaan te maken	#undef SYMBOL
`#warning`	Hiermee kunnen we een waarschuwing van niveau 1 genereren op basis van onze code	#warning warning-message
`#error`	Hiermee kunnen we een fout genereren uit onze code	#error error-message
`#line`	Hiermee kunnen we het regelnummer en de bestandsnaam van de compiler wijzigen om fouten en waarschuwingen weer te geven	#line line-number file-name
`#region`	Hiermee kunnen we een regio maken die kan worden uitgevouwen of samengevouwen bij gebruik van een Visual Studio Code Editor	#region region-description codes #endregion
`#endregion`	Geeft het einde van een regio aan	#region region-description codes #endregion
`#pragma`	Geeft de compiler speciale instructies voor het compileren van het bestand waarin het voorkomt.	#pragma pragma-name pragma-arguments

#define richtlijn

De #define richtlijn stelt ons in staat om een symbool te definiëren.
Symbolen die worden gedefinieerd bij gebruik in combinatie met #if richtlijn zal evalueren naar waar.
Deze symbolen kunnen worden gebruikt om voorwaarden voor compilatie op te geven.
Syntaxis:
```
#define SYMBOL
```
Bijvoorbeeld:
```
#define TESTING
```
Hier is TESTEN een symbool.

#undef richtlijn

De #undef richtlijn stelt ons in staat om een symbool ongedaan te maken.
Ongedefinieerde symbolen bij gebruik in combinatie met #if richtlijn zal evalueren naar onwaar.
Syntaxis:
```
#undef SYMBOL
```
Bijvoorbeeld:
```
#undef TESTING
```
Hier is TESTEN een symbool.

#if richtlijn

De #if richtlijn worden gebruikt om de preprocessor-expressie te testen.
Een preprocessor-expressie kan bestaan uit alleen een symbool of een combinatie van symbolen samen met operators zoals && (EN), || (OF), ! (NIET).
#if instructie wordt gevolgd door een #endif richtlijn.
De codes in de #if richtlijn wordt alleen gecompileerd als de expressie getest met #if evalueert tot waar.

Syntaxis:

#if preprocessor-expression
	code to compile<
#endif

Bijvoorbeeld:

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

Voorbeeld 1:Hoe gebruik ik de #if-richtlijn?

#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 het bovenstaande programma, CSHARP symbool wordt gedefinieerd met behulp van de #define richtlijn aan het begin van het programma. In de Main() methode, #if richtlijn wordt gebruikt om te testen of CSHARP is waar of niet. Het codeblok in #if richtlijn wordt alleen gecompileerd als CSHARP is gedefinieerd.

#elif-richtlijn

De #elif richtlijn wordt gebruikt samen met #if richtlijn waarmee we een samengestelde voorwaardelijke richtlijn kunnen maken.
Het wordt gebruikt bij het testen van meerdere preprocessor-expressies.
De codes in de #elif richtlijn wordt alleen gecompileerd als de uitdrukking die is getest met die #elif evalueert tot waar.

Syntaxis:

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

Bijvoorbeeld:

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

#else richtlijn

De #else richtlijn wordt gebruikt samen met #if richtlijn.
Als geen van de uitdrukkingen in de voorgaande #if en #elif (indien aanwezig) richtlijnen zijn waar, de codes binnen de #else richtlijn zal worden opgesteld.

Syntaxis:

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

Bijvoorbeeld:

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

#endif richtlijn

De #endif richtlijn wordt gebruikt samen met #if instructie om het einde van #if aan te geven richtlijn.

Syntaxis:

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

Bijvoorbeeld:

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

Voorbeeld 2:Hoe gebruik je een voorwaardelijke richtlijn (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
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

CSHARP is defined, PYTHON is undefined

In dit voorbeeld zien we het gebruik van #elif en #else richtlijn. Deze richtlijn wordt gebruikt wanneer er meerdere voorwaarden moeten worden getest. Ook kunnen symbolen worden gecombineerd met behulp van logische operatoren om een preprocessor-expressie te vormen.

#warning richtlijn

De #warning richtlijn stelt ons in staat om een door de gebruiker gedefinieerde niveau één waarschuwing te genereren uit onze code.
Syntaxis:
```
#warning warning-message
```
Bijvoorbeeld:
```
#warning This is a warning message
```

Voorbeeld 3:Hoe de #warning-richtlijn te gebruiken?

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

Wanneer we het programma uitvoeren, is de uitvoer:

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

Na het uitvoeren van het bovenstaande programma, zullen we de uitvoer zien zoals hierboven. De tekst vertegenwoordigt een waarschuwingsbericht. Hier genereren we een door de gebruiker gedefinieerd waarschuwingsbericht met behulp van de #warning richtlijn.

Merk op dat de instructies na de #warning richtlijn worden ook uitgevoerd. Het betekent dat de #warning instructie beëindigt het programma niet, maar geeft alleen een waarschuwing.

#foutrichtlijn

De #error richtlijn stelt ons in staat om een door de gebruiker gedefinieerde fout van onze code te genereren.
Syntaxis:
```
#error error-message
```
Bijvoorbeeld:
```
#error This is an error message
```

Voorbeeld 4:Hoe gebruik ik de #error-richtlijn?

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

Wanneer we het programma uitvoeren, is de uitvoer:

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 zullen enkele fouten zien, waarschijnlijk zoals hierboven. Hier genereren we een door de gebruiker gedefinieerde fout.

Een ander ding om op te merken is dat het programma zal worden beëindigd en de regel #error directive example wordt niet afgedrukt zoals in de #warning richtlijn.

#line richtlijn

De #line richtlijn stelt ons in staat om het regelnummer en de bestandsnaam te wijzigen voor fouten en waarschuwingen.
Syntaxis:
```
#line line-number file-name
```
Bijvoorbeeld:
```
#line 50 "fakeprogram.cs"
```

Voorbeeld 5:Hoe gebruik ik de #line-instructie?

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

Wanneer we het programma uitvoeren, is de uitvoer:

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 hebben het bovenstaande voorbeeld opgeslagen als Program.cs . De waarschuwing is eigenlijk gegenereerd om line 10 door Program.cs . De #line gebruiken richtlijn hebben we het regelnummer gewijzigd in 200 en de bestandsnaam naar AnotherProgram.cs die de fout heeft gegenereerd.

#region en #endregion richtlijn

De #region richtlijn stelt ons in staat om een regio te maken die kan worden uitgevouwen of samengevouwen bij gebruik van een Visual Studio Code Editor.
Deze richtlijn wordt alleen gebruikt om de code te ordenen.
Het #region-blok mag niet overlappen met een #if blok. Echter, een #region blok kan worden opgenomen in een #if blok en een #if blok kan overlappen met een #region blok.
#endregion instructie geeft het einde aan van een #region blok.

Syntaxis:

#region region-description
	codes
#endregion

Voorbeeld 6:Hoe gebruik ik de #regionrichtlijn?

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

Wanneer we het programma uitvoeren, is de uitvoer:

Hello
Hello
Hello
Hello
Hello

#pragma richtlijn

De #pragma richtlijn wordt gebruikt om de compiler een aantal speciale instructies te geven voor de compilatie van het bestand waarin het voorkomt.
De instructie kan het in- of uitschakelen van enkele waarschuwingen bevatten.
C# ondersteunt twee #pragma instructies:
- #pragma warning :Gebruikt voor het in- of uitschakelen van waarschuwingen
- #pragma checksum :Het genereert controlesommen voor bronbestanden die zullen worden gebruikt voor debuggen.
Syntaxis:
```
#pragma pragma-name pragma-arguments
```
Bijvoorbeeld:
```
#pragma warning disable
```

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): warning CS1030: #warning: 'This is a warning 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 aanvankelijk 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).

C# Type conversie Naamruimten in C#-programmering

C Taal