Directivas de preprocesador de C#

En este tutorial, aprenderemos sobre las directivas de preprocesador, las directivas disponibles en C# y cuándo, por qué y cómo se usan.

Como su nombre lo justifica, las directivas de preprocesador son un bloque de declaraciones que se procesan antes de que comience la compilación real. Las directivas de preprocesador de C# son los comandos para el compilador que afectan el proceso de compilación.

Estos comandos especifican qué secciones del código compilar o cómo manejar errores y advertencias específicos.

La directiva de preprocesador de C# comienza con un # (hash) El símbolo y todas las directivas del preprocesador duran una línea. Las directivas de preprocesador terminan con new line en lugar de semicolon .

Las directivas de preprocesador disponibles en C# son:

Directivas de preprocesador en C#
Directiva de preprocesador	Descripción	Sintaxis
`#if`	Comprueba si una expresión del preprocesador es verdadera o no	#if preprocessor-expression code to compile #endif
`#elif`	Usado junto con `#if` para verificar múltiples expresiones de preprocesador	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Usado junto con `#if` para crear una directiva condicional compuesta.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Usado junto con `#if` para indicar el final de una directiva condicional	#if preprocessor-expression code to compile #endif
`#define`	Usado para definir un símbolo	#define SYMBOL
`#undef`	Usado para anular la definición de un símbolo	#undef SYMBOL
`#warning`	Nos permite generar una advertencia de nivel 1 desde nuestro código	#warning warning-message
`#error`	Nos permite generar errores a partir de nuestro código	#error error-message
`#line`	Nos permite modificar el número de línea y el nombre de archivo del compilador para mostrar errores y advertencias	#line line-number file-name
`#region`	Nos permite crear una región que se puede expandir o contraer cuando se usa un editor de código de Visual Studio	#region region-description codes #endregion
`#endregion`	Indica el final de una región	#region region-description codes #endregion
`#pragma`	Le da al compilador instrucciones especiales para la compilación del archivo en el que aparece.	#pragma pragma-name pragma-arguments

directiva #define

El #define directiva nos permite definir un símbolo.
Símbolos que se definen cuando se usan junto con #if la directiva se evaluará como verdadera.
Estos símbolos se pueden usar para especificar condiciones para la compilación.
Sintaxis:
```
#define SYMBOL
```
Por ejemplo:
```
#define TESTING
```
Aquí, PRUEBA es un símbolo.

directiva #undef

El #undef directiva nos permite anular la definición de un símbolo.
Símbolos indefinidos cuando se usan junto con #if la directiva se evaluará como falsa.
Sintaxis:
```
#undef SYMBOL
```
Por ejemplo:
```
#undef TESTING
```
Aquí, PRUEBA es un símbolo.

directiva #if

El #if directiva se utilizan para probar la expresión del preprocesador.
Una expresión de preprocesador puede consistir solo en un símbolo o una combinación de símbolos junto con operadores como && (Y), || (O), ! (NO).
#if directiva va seguida de un #endif directiva.
Los códigos dentro del #if la directiva se compila solo si la expresión probada con #if se evalúa como verdadero.

Sintaxis:

#if preprocessor-expression
	code to compile<
#endif

Por ejemplo:

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

Ejemplo 1:¿Cómo usar la directiva #if?

#define CSHARP

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

Cuando ejecutamos el programa, la salida será:

CSHARP is defined

En el programa anterior, CSHARP el símbolo se define usando el #define directiva al comienzo del programa. Dentro del Main() método, #if directiva se utiliza para probar si CSHARP es cierto o no. El bloque de código dentro de #if la directiva se compila solo si CSHARP está definido.

directiva #elif

El #elif La directiva se usa junto con la directiva #if que nos permite crear una directiva condicional compuesta.
Se usa cuando se prueba la expresión de varios preprocesadores.
Los códigos dentro del #elif la directiva se compila solo si la expresión probada con ese #elif se evalúa como verdadero.

Sintaxis:

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

Por ejemplo:

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

directiva #else

El #else la directiva se usa junto con #if directiva.
Si ninguna de las expresiones del #if anterior y #elif (si están presentes) las directivas son verdaderas, los códigos dentro del #else se compilará la directiva.

Sintaxis:

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

Por ejemplo:

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

directiva #endif

El #endif la directiva se usa junto con #if directiva para indicar el final de #if directiva.

Sintaxis:

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

Por ejemplo:

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

Ejemplo 2:¿Cómo usar la directiva condicional (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
		}
	}
}

Cuando ejecutamos el programa, la salida será:

CSHARP is defined, PYTHON is undefined

En este ejemplo, podemos ver el uso de #elif y #else directiva. Estas directivas se utilizan cuando hay múltiples condiciones para probar. Además, los símbolos se pueden combinar mediante operadores lógicos para formar una expresión de preprocesador.

directiva #warning

Los #warning La directiva nos permite generar una advertencia de nivel uno definida por el usuario a partir de nuestro código.
Sintaxis:
```
#warning warning-message
```
Por ejemplo:
```
#warning This is a warning message
```

Ejemplo 3:¿Cómo usar la directiva #warning?

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

Cuando ejecutamos el programa, la salida será:

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

Después de ejecutar el programa anterior, veremos la salida como se muestra arriba. El texto representa un mensaje de advertencia. Aquí, estamos generando un mensaje de advertencia definido por el usuario usando el #warning directiva.

Tenga en cuenta que las declaraciones después de #warning directiva también se ejecutan. Significa que el #warning La directiva no finaliza el programa, sino que solo muestra una advertencia.

directiva #error

El #error directiva nos permite generar un error definido por el usuario a partir de nuestro código.
Sintaxis:
```
#error error-message
```
Por ejemplo:
```
#error This is an error message
```

Ejemplo 4:¿Cómo usar la directiva #error?

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

Cuando ejecutamos el programa, la salida será:

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.

Veremos algunos errores, probablemente como el anterior. Aquí estamos generando un error definido por el usuario.

Otra cosa a tener en cuenta aquí es que el programa terminará y la línea #error directive example no se imprimirá como estaba en el #warning directiva.

directiva #line

El #line directiva nos permite modificar el número de línea y el nombre de archivo para errores y advertencias.
Sintaxis:
```
#line line-number file-name
```
Por ejemplo:
```
#line 50 "fakeprogram.cs"
```

Ejemplo 5:¿Cómo usar la directiva #line?

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

Cuando ejecutamos el programa, la salida será:

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]

Hemos guardado el ejemplo anterior como Program.cs . La advertencia en realidad se generó en line 10 por Program.cs . Usando el #line directiva, hemos cambiado el número de línea a 200 y el nombre del archivo a AnotherProgram.cs que generó el error.

Directiva #region y #endregion

El #region La directiva nos permite crear una región que se puede expandir o contraer cuando se usa un editor de código de Visual Studio.
Esta directiva se usa simplemente para organizar el código.
El bloque #region no puede superponerse con un #if bloquear. Sin embargo, un #region el bloque se puede incluir dentro de un #if bloque y un #if el bloque puede superponerse con un #region bloque.
#endregion directiva indica el final de un #region bloque.

Sintaxis:

#region region-description
	codes
#endregion

Ejemplo 6:¿Cómo usar la directiva #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
		}
	}
}

Cuando ejecutamos el programa, la salida será:

Hello
Hello
Hello
Hello
Hello

Directiva #pragma

El #pragma La directiva se utiliza para dar al compilador algunas instrucciones especiales para la compilación del archivo en el que aparece.
La instrucción puede incluir desactivar o activar algunas advertencias.
C# admite dos #pragma instrucciones:
- #pragma warning :se usa para deshabilitar o habilitar las advertencias
- #pragma checksum :Genera sumas de verificación para los archivos fuente que se utilizarán para la depuración.
Sintaxis:
```
#pragma pragma-name pragma-arguments
```
Por ejemplo:
```
#pragma warning disable
```

Ejemplo 7:¿Cómo usar la directiva #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
		}
	}
}

Cuando ejecutamos el programa, la salida será:

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

Podemos ver que solo la segunda advertencia se muestra en la pantalla de salida.

Esto se debe a que inicialmente deshabilitamos todas las advertencias antes de la primera advertencia y las restablecimos solo antes de la segunda advertencia. Esta es la razón por la que se ocultó la primera advertencia.

También podemos deshabilitar advertencias específicas en lugar de todas las advertencias.

Para obtener más información sobre #pragma , visita #pragma (referencia de C#).

Conversión de tipo C# Espacios de nombres en la programación de C#

Lenguaje C