C#-Präprozessordirektiven
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ä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 Sprache