Arahan C# Preprocessor

Petunjuk C# Preprocessor

Dalam tutorial ini, kita akan belajar tentang Preprocessor Directive, directive yang tersedia dalam C#, dan kapan, mengapa, dan bagaimana penggunaannya.

Seperti namanya, arahan preprocessor adalah blok pernyataan yang diproses sebelum kompilasi yang sebenarnya dimulai. C# preprocessor directives adalah perintah untuk compiler yang mempengaruhi proses kompilasi.

Perintah ini menentukan bagian kode mana yang akan dikompilasi atau bagaimana menangani kesalahan dan peringatan tertentu.

C# preprocessor directive dimulai dengan # (hash) simbol dan semua arahan preprocessor bertahan selama satu baris. Direktif praprosesor diakhiri oleh new line daripada semicolon .

Direktif preprocessor yang tersedia di C# adalah:

Direktif praprosesor dalam C#
Petunjuk Praprosesor	Deskripsi	Sintaks
`#if`	Memeriksa apakah ekspresi praprosesor benar atau tidak	#if preprocessor-expression code to compile #endif
`#elif`	Digunakan bersama dengan `#if` untuk memeriksa beberapa ekspresi praprosesor	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Digunakan bersama dengan `#if` untuk membuat direktif kondisional majemuk.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Digunakan bersama dengan `#if` untuk menunjukkan akhir dari direktif bersyarat	#if preprocessor-expression code to compile #endif
`#define`	Digunakan untuk mendefinisikan simbol	#define SYMBOL
`#undef`	Digunakan untuk tidak mendefinisikan simbol	#undef SYMBOL
`#warning`	Memungkinkan kami untuk menghasilkan peringatan level 1 dari kode kami	#warning warning-message
`#error`	Memungkinkan kami untuk menghasilkan kesalahan dari kode kami	#error error-message
`#line`	Memungkinkan kami untuk mengubah nomor baris dan nama file kompilator untuk menampilkan kesalahan dan peringatan	#line line-number file-name
`#region`	Memungkinkan kami untuk membuat wilayah yang dapat diperluas atau diciutkan saat menggunakan Editor Kode Visual Studio	#region region-description codes #endregion
`#endregion`	Menunjukkan akhir suatu wilayah	#region region-description codes #endregion
`#pragma`	Memberikan instruksi khusus kepada kompiler untuk kompilasi file tempat file tersebut muncul.	#pragma pragma-name pragma-arguments

#define direktif

#define direktif memungkinkan kita untuk mendefinisikan simbol.
Simbol yang ditentukan saat digunakan bersama dengan #if direktif akan bernilai benar.
Simbol ini dapat digunakan untuk menentukan kondisi kompilasi.
Sintaks:
```
#define SYMBOL
```
Misalnya:
```
#define TESTING
```
Di sini, PENGUJIAN adalah simbol.

#perintah undef

#undef direktif memungkinkan kita untuk tidak mendefinisikan simbol.
Simbol yang tidak ditentukan saat digunakan bersama dengan #if direktif akan bernilai false.
Sintaks:
```
#undef SYMBOL
```
Misalnya:
```
#undef TESTING
```
Di sini, PENGUJIAN adalah simbol.

#if direktif

#if direktif digunakan untuk menguji ekspresi praprosesor.
Ekspresi praprosesor dapat terdiri dari simbol saja atau kombinasi simbol bersama dengan operator seperti && (DAN), || (ATAU), ! (TIDAK).
#if direktif diikuti oleh #endif arahan.
Kode di dalam #if direktif dikompilasi hanya jika ekspresi diuji dengan #if bernilai benar.

Sintaks:

#if preprocessor-expression
	code to compile<
#endif

Misalnya:

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

Contoh 1:Bagaimana cara menggunakan arahan #if?

#define CSHARP

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

Saat kita menjalankan program, outputnya adalah:

CSHARP is defined

Pada program di atas, CSHARP simbol didefinisikan menggunakan #define arahan di awal program. Di dalam Main() metode, #if direktif digunakan untuk menguji apakah CSHARP benar atau tidak. Blok kode di dalam #if direktif dikompilasi hanya jika CSHARP didefinisikan.

#elif arahan

#elif direktif digunakan bersama dengan direktif #if yang memungkinkan kita membuat direktif kondisional majemuk.
Ini digunakan saat menguji beberapa ekspresi praprosesor.
Kode di dalam #elif direktif dikompilasi hanya jika ekspresi diuji dengan #elif bernilai benar.

Sintaks:

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

Misalnya:

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

#perintah lain

#else direktif digunakan bersama dengan #if arahan.
Jika tidak ada ekspresi dalam #if sebelumnya dan #elif (jika ada) direktif benar, kode di dalam #else direktif akan dikompilasi.

Sintaks:

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

Misalnya:

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

#endif direktif

#endif direktif digunakan bersama dengan #if direktif untuk menunjukkan akhir dari #if arahan.

Sintaks:

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

Misalnya:

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

Contoh 2:Bagaimana cara menggunakan 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
		}
	}
}

Saat kita menjalankan program, outputnya adalah:

CSHARP is defined, PYTHON is undefined

Dalam contoh ini, kita dapat melihat penggunaan #elif dan #else pengarahan. Arahan ini digunakan ketika ada beberapa kondisi yang akan diuji. Selain itu, simbol dapat digabungkan menggunakan operator logika untuk membentuk ekspresi praprosesor.

#perintah peringatan

#warning direktif memungkinkan kami untuk menghasilkan peringatan tingkat satu yang ditentukan pengguna dari kode kami.
Sintaks:
```
#warning warning-message
```
Misalnya:
```
#warning This is a warning message
```

Contoh 3:Bagaimana cara menggunakan #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");
		}
	}
}

Saat kita menjalankan program, outputnya adalah:

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

Setelah menjalankan program di atas, kita akan melihat output seperti di atas. Teks tersebut mewakili pesan peringatan. Di sini, kami membuat pesan peringatan yang ditentukan pengguna menggunakan #warning arahan.

Perhatikan bahwa pernyataan setelah #warning direktif juga dijalankan. Artinya #warning direktif tidak menghentikan program tetapi hanya memberikan peringatan.

#perintah kesalahan

#error direktif memungkinkan kami untuk menghasilkan kesalahan yang ditentukan pengguna dari kode kami.
Sintaks:
```
#error error-message
```
Misalnya:
```
#error This is an error message
```

Contoh 4:Bagaimana cara menggunakan #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");
		}
	}
}

Saat kita menjalankan program, outputnya adalah:

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.

Kita akan melihat beberapa kesalahan, mungkin seperti di atas. Di sini kami membuat kesalahan yang ditentukan pengguna.

Hal lain yang perlu diperhatikan di sini adalah program akan dihentikan dan baris #error directive example tidak akan dicetak seperti di #warning arahan.

#line direktif

#line direktif memungkinkan kita untuk mengubah nomor baris dan nama file untuk kesalahan dan peringatan.
Sintaks:
```
#line line-number file-name
```
Misalnya:
```
#line 50 "fakeprogram.cs"
```

Contoh 5:Bagaimana cara menggunakan #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
		}
	}
}

Saat kita menjalankan program, outputnya adalah:

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]

Kami telah menyimpan contoh di atas sebagai Program.cs . Peringatan sebenarnya dibuat di line 10 oleh Program.cs . Menggunakan #line direktif, kami telah mengubah nomor baris menjadi 200 dan nama file menjadi AnotherProgram.cs yang menghasilkan kesalahan.

#region dan #endregion direktif

#region direktif memungkinkan kita untuk membuat wilayah yang dapat diperluas atau diciutkan saat menggunakan Editor Kode Visual Studio.
Direktif ini hanya digunakan untuk mengatur kode.
Blok #region tidak boleh tumpang tindih dengan #if memblokir. Namun, sebuah #region blok dapat dimasukkan dalam #if blok dan #if blok dapat tumpang tindih dengan #region blokir.
#endregion direktif menunjukkan akhir dari #region blokir.

Sintaks:

#region region-description
	codes
#endregion

Contoh 6:Bagaimana cara menggunakan arahan #region?

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

Saat kita menjalankan program, outputnya adalah:

Hello
Hello
Hello
Hello
Hello

#pragma direktif

#pragma direktif digunakan untuk memberikan kompiler beberapa instruksi khusus untuk kompilasi file di mana ia muncul.
Petunjuknya mungkin termasuk menonaktifkan atau mengaktifkan beberapa peringatan.
C# mendukung dua #pragma instruksi:
- #pragma warning :Digunakan untuk menonaktifkan atau mengaktifkan peringatan
- #pragma checksum :Ini menghasilkan checksum untuk file sumber yang akan digunakan untuk debugging.
Sintaks:
```
#pragma pragma-name pragma-arguments
```
Misalnya:
```
#pragma warning disable
```

Contoh 7:Bagaimana cara menggunakan arahan #pragma?

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

Saat kita menjalankan program, outputnya adalah:

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

Kita dapat melihat bahwa hanya peringatan kedua ditampilkan pada layar keluaran.

Ini karena, awalnya kami menonaktifkan semua peringatan sebelum peringatan pertama dan memulihkannya hanya sebelum peringatan kedua. Inilah alasan mengapa peringatan pertama disembunyikan.

Kami juga dapat menonaktifkan peringatan khusus alih-alih semua peringatan.

Untuk mempelajari lebih lanjut tentang #pragma , kunjungi #pragma (referensi C#).

Konversi Tipe C# Ruang nama dalam Pemrograman C#

Bahasa C