C#-Präprozessordirektiven

In diesem Tutorial erfahren wir mehr über Präprozessordirektiven, verfügbare Direktiven in C# und wann, warum und wie warum sie verwendet werden.

Wie der Name schon sagt, sind Präprozessordirektiven ein Block von Anweisungen, die verarbeitet werden, bevor die eigentliche Kompilierung beginnt. C#-Präprozessordirektiven sind die Befehle für den Compiler, die den Kompilierungsprozess beeinflussen.

Diese Befehle geben an, welche Abschnitte des Codes kompiliert werden sollen oder wie bestimmte Fehler und Warnungen behandelt werden sollen.

Die C#-Präprozessordirektive beginnt mit einem # (hash) Symbol und alle Präprozessoranweisungen dauern eine Zeile. Präprozessordirektiven werden durch new line beendet statt semicolon .

Die in C# verfügbaren Präprozessordirektiven sind:

Präprozessordirektiven in C#
Präprozessordirektive	Beschreibung	Syntax
`#if`	Überprüft, ob ein Präprozessorausdruck wahr ist oder nicht	#if preprocessor-expression code to compile #endif
`#elif`	Wird zusammen mit `#if` verwendet um mehrere Präprozessorausdrücke zu prüfen	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Wird zusammen mit `#if` verwendet zusammengesetzte bedingte Direktive zu erstellen.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Wird zusammen mit `#if` verwendet um das Ende einer bedingten Direktive anzuzeigen	#if preprocessor-expression code to compile #endif
`#define`	Wird verwendet, um ein Symbol zu definieren	#define SYMBOL
`#undef`	Wird verwendet, um die Definition eines Symbols aufzuheben	#undef SYMBOL
`#warning`	Ermöglicht es uns, eine Warnung der Stufe 1 aus unserem Code zu generieren	#warning warning-message
`#error`	Ermöglicht es uns, Fehler aus unserem Code zu generieren	#error error-message
`#line`	Erlaubt uns, die Zeilennummer und den Dateinamen des Compilers zu ändern, um Fehler und Warnungen anzuzeigen	#line line-number file-name
`#region`	Ermöglicht es uns, einen Bereich zu erstellen, der bei Verwendung eines Visual Studio-Code-Editors erweitert oder reduziert werden kann	#region region-description codes #endregion
`#endregion`	Gibt das Ende einer Region an	#region region-description codes #endregion
`#pragma`	Gibt dem Compiler spezielle Anweisungen für die Kompilierung der Datei, in der es erscheint.	#pragma pragma-name pragma-arguments

#define-Anweisung

Der #define Direktive erlaubt es uns, ein Symbol zu definieren.
Symbole, die definiert werden, wenn sie zusammen mit #if verwendet werden Direktive wird als wahr ausgewertet.
Diese Symbole können verwendet werden, um Bedingungen für die Kompilierung anzugeben.
Syntax:
```
#define SYMBOL
```
Zum Beispiel:
```
#define TESTING
```
TESTEN ist hier ein Symbol.

#undef-Anweisung

Der #undef Direktive erlaubt es uns, ein Symbol aufzuheben.
Undefinierte Symbole bei Verwendung zusammen mit #if Direktive wird als falsch ausgewertet.
Syntax:
```
#undef SYMBOL
```
Zum Beispiel:
```
#undef TESTING
```
TESTEN ist hier ein Symbol.

#if-Anweisung

Die #if Direktive werden verwendet, um den Präprozessorausdruck zu testen.
Ein Präprozessorausdruck kann nur aus einem Symbol oder einer Kombination von Symbolen zusammen mit Operatoren wie && bestehen (UND), || (ODER), ! (NICHT).
#if Direktive folgt ein #endif Richtlinie.
Die Codes innerhalb des #if Direktive wird nur kompiliert, wenn der Ausdruck mit #if getestet wurde wird als wahr ausgewertet.

Syntax:

#if preprocessor-expression
	code to compile<
#endif

Zum Beispiel:

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

Beispiel 1:Wie wird die #if-Direktive verwendet?

#define CSHARP

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

CSHARP is defined

Im obigen Programm CSHARP Symbol wird mit dem #define definiert Anweisung am Anfang des Programms. Innerhalb des Main() Methode, #if Direktive wird verwendet, um zu testen, ob CSHARP wahr ist oder nicht. Der Codeblock in #if Direktive wird nur kompiliert, wenn CSHARP ist definiert.

#elif-Direktive

Der #elif Die Direktive wird zusammen mit der #if-Direktive verwendet, mit der wir eine zusammengesetzte bedingte Direktive erstellen können.
Es wird beim Testen mehrerer Präprozessor-Ausdrücke verwendet.
Die Codes in #elif Direktive wird nur kompiliert, wenn der Ausdruck mit diesem #elif getestet wurde wird als wahr ausgewertet.

Syntax:

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

Zum Beispiel:

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

#else-Anweisung

Der #else Direktive wird zusammen mit #if verwendet Richtlinie.
Wenn keiner der Ausdrücke im vorhergehenden #if und #elif (falls vorhanden) Direktiven sind wahr, die Codes innerhalb des #else Direktive wird kompiliert.

Syntax:

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

Zum Beispiel:

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

#endif-Anweisung

Der #endif Direktive wird zusammen mit #if verwendet Direktive, um das Ende von #if anzuzeigen Richtlinie.

Syntax:

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

Zum Beispiel:

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

Beispiel 2:Wie verwendet man die bedingte Direktive (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
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

CSHARP is defined, PYTHON is undefined

In diesem Beispiel sehen wir die Verwendung von #elif und #else Richtlinie. Diese Anweisungen werden verwendet, wenn mehrere Bedingungen getestet werden müssen. Außerdem können Symbole mit logischen Operatoren kombiniert werden, um einen Präprozessorausdruck zu bilden.

#Warnungsanweisung

Der #warning Direktive erlaubt es uns, eine benutzerdefinierte Warnung der Stufe 1 aus unserem Code zu generieren.
Syntax:
```
#warning warning-message
```
Zum Beispiel:
```
#warning This is a warning message
```

Beispiel 3:Wie wird die #warning-Direktive verwendet?

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Nachdem Sie das obige Programm ausgeführt haben, sehen wir die Ausgabe wie oben. Der Text stellt eine Warnmeldung dar. Hier generieren wir eine benutzerdefinierte Warnmeldung mit dem #warning Richtlinie.

Beachten Sie, dass die Anweisungen nach dem #warning werden ebenfalls ausgeführt. Das bedeutet, dass #warning -Anweisung beendet das Programm nicht, sondern gibt nur eine Warnung aus.

#Fehlerdirektive

Der #error Direktive erlaubt es uns, einen benutzerdefinierten Fehler aus unserem Code zu generieren.
Syntax:
```
#error error-message
```
Zum Beispiel:
```
#error This is an error message
```

Beispiel 4:Wie wird die #error-Direktive verwendet?

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

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.

Wir werden einige Fehler sehen, wahrscheinlich wie oben. Hier erzeugen wir einen benutzerdefinierten Fehler.

Hier ist noch zu beachten, dass das Programm beendet wird und die Zeile #error directive example wird nicht wie in #warning gedruckt Richtlinie.

#line-Direktive

Der #line erlaubt es uns, die Zeilennummer und den Dateinamen für Fehler und Warnungen zu ändern.
Syntax:
```
#line line-number file-name
```
Zum Beispiel:
```
#line 50 "fakeprogram.cs"
```

Beispiel 5:Wie wird die #line-Direktive verwendet?

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

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]

Wir haben das obige Beispiel als Program.cs gespeichert . Die Warnung wurde tatsächlich bei line 10 generiert durch Program.cs . Mit dem #line Direktive haben wir die Zeilennummer in 200 geändert und den Dateinamen zu AnotherProgram.cs die den Fehler erzeugt hat.

#region- und #endregion-Direktive

Der #region -Direktive ermöglicht es uns, einen Bereich zu erstellen, der bei Verwendung eines Visual Studio-Code-Editors erweitert oder reduziert werden kann.
Diese Direktive wird einfach verwendet, um den Code zu organisieren.
Der Block #region darf sich nicht mit einem #if überschneiden Block. Allerdings ein #region -Block kann innerhalb eines #if enthalten sein Block und ein #if Block kann sich mit einem #region überschneiden blockieren.
#endregion Direktive gibt das Ende eines #region an blockieren.

Syntax:

#region region-description
	codes
#endregion

Beispiel 6:Wie wird die Direktive #region verwendet?

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

Hello
Hello
Hello
Hello
Hello

#pragma-Direktive

Die #pragma Direktive wird verwendet, um dem Compiler einige spezielle Anweisungen für die Kompilierung der Datei zu geben, in der sie erscheint.
Die Anweisung kann das Deaktivieren oder Aktivieren einiger Warnungen beinhalten.
C# unterstützt zwei #pragma Anweisungen:
- #pragma warning :Wird zum Deaktivieren oder Aktivieren von Warnungen verwendet
- #pragma checksum :Es generiert Prüfsummen für Quelldateien, die zum Debuggen verwendet werden.
Syntax:
```
#pragma pragma-name pragma-arguments
```
Zum Beispiel:
```
#pragma warning disable
```

Beispiel 7:Wie wird die #pragma-Direktive verwendet?

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

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Das sehen wir nur bei der zweiten Warnung wird auf dem Ausgabebildschirm angezeigt.

Dies liegt daran, dass wir zunächst alle Warnungen vor der ersten Warnung deaktiviert und erst vor der zweiten Warnung wiederhergestellt haben. Aus diesem Grund wurde die erste Warnung ausgeblendet.

Wir können auch bestimmte Warnungen anstelle aller Warnungen deaktivieren.

Um mehr über #pragma zu erfahren , besuchen Sie #pragma (C#-Referenz).

C#-Typkonvertierung Namespaces in der C#-Programmierung

C Sprache