C# Directivas de preprocesador

Las directivas de preprocesador (Preprocessor Directives) guían al compilador para preprocesar la información antes de que comience la compilación real.

A través de estas directivas, se puede controlar cómo compila el compilador los archivos o qué partes compila. Las directivas de preprocesador comunes incluyen la compilación condicional, la definición de macros, etc.

Todas las directivas de preprocesador comienzan con#y, en una sola línea, solo pueden aparecer caracteres de espacio en blanco delante de la directiva de preprocesador.

Las directivas de preprocesador no son instrucciones, por lo que no terminan con un punto y coma;al final.

El compilador de C# no tiene un preprocesador separado, pero las directivas se procesan como si hubiera un preprocesador separado. En C#, las directivas de preprocesador se utilizan para la compilación condicional. A diferencia de C y C++, no se utilizan para crear macros. Una directiva de preprocesador debe ser la única directiva en esa línea.

Lista de directivas de preprocesador de C#

La siguiente tabla enumera las directivas de preprocesador disponibles en C#:

DirectivaDescripción
#defineDefine un símbolo que se puede utilizar para la compilación condicional.
#undefCancela la definición de un símbolo.
#ifInicia un bloque de compilación condicional; si el símbolo está definido, se incluye el bloque de código.
#elifSi la condición anterior#ifo#elifno se cumple, y la condición actual se cumple, entonces se incluye el bloque de código.
#elseSi la condición anterior#ifo#elifno se cumple, entonces se incluye el bloque de código.
#endifFinaliza un bloque de compilación condicional.
#warningGenera un mensaje de advertencia del compilador.
#errorGenera un mensaje de error del compilador.
#regionMarca una región de código que se puede plegar y expandir en el IDE, facilitando la organización y lectura del código.
#endregionFinaliza una región de código.
#lineCambia el número de línea y el nombre de archivo en la salida del compilador; puede utilizarse para depurar o para código generado por herramientas.
#pragmaSe utiliza para enviar instrucciones especiales al compilador, por ejemplo, deshabilitar o restaurar advertencias específicas.
#nullableControla el contexto y las anotaciones de nulabilidad, lo que permite habilitar o deshabilitar las comprobaciones del compilador para los tipos de referencia anulables.

Ejemplo

#define DEBUG

#if DEBUG
    Console.WriteLine("Debug mode");
#elif RELEASE
    Console.WriteLine("Release mode");
#else
    Console.WriteLine("Other mode");
#endif

#warning This is a warning message
#error This is an error message

#region MyRegion
    // Your code here
#endregion

#line 100 "MyFile.cs"
    // The next line will be reported as line 100 in MyFile.cs
    Console.WriteLine("This is line 100");
#line default
    // Line numbering returns to normal

#pragma warning disable 414
    private int unusedVariable;
#pragma warning restore 414

#nullable enable
    string? nullableString = null;
#nullable disable

Directivas de preprocesador #define y #undef

#defineSe utiliza para definir un símbolo (generalmente para compilación condicional),#undefSe utiliza para cancelar la definición de un símbolo.

#define DEBUG

#undef RELEASE

#define le permite definir un símbolo; de esta manera, al usar el símbolo como expresión pasada a la directiva #if, la expresión devolverá true. Su sintaxis es la siguiente:

#define symbol

El siguiente programa ilustra esto:

Ejemplo

#define PI
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y se ejecuta, produce el siguiente resultado:

PI is defined

Directivas condicionales: #if, #elif, #else y #endif

Puede utilizar la#ifdirectiva para crear una directiva condicional.

Las directivas condicionales se utilizan para comprobar si un símbolo es verdadero. Si es verdadero, el compilador ejecuta#ifel código comprendido entre esa directiva y la siguiente.

La sintaxis de las directivas condicionales es:

#if symbol [operator symbol]...

Donde,symboles el nombre del símbolo que se va a probar. También puede usar true y false, o colocar el operador de negación delante del símbolo.

Los operadores comunes son:

  • == (igual a)
  • != (no igual a)
  • && (y)
  • || (o)

También puede usar paréntesis para agrupar símbolos y operadores. Las directivas condicionales se utilizan para compilar código en versiones de depuración o al compilar una configuración específica. Una directiva que comience con#ifdebe terminar explícitamente con una#endifdirectiva.

#define DEBUG

#if DEBUG
    Console.WriteLine("Debug mode");
#elif RELEASE
    Console.WriteLine("Release mode");
#else
    Console.WriteLine("Other mode");
#endif

El siguiente programa demuestra el uso de las directivas condicionales:

Ejemplo

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
   public static void Main()
   {

      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG and VC_V10 are defined");
      #else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
      #endif
      Console.ReadKey();
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

DEBUG and VC_V10 are defined

#warning y #error

#warning se utiliza para generar advertencias del compilador y #error para generar errores del compilador.

#warning This is a warning message
#error This is an error message

#region y #endregion

Se utilizan para plegar código, haciendo que el código sea más legible.

#region MyRegion
    // Your code here
#endregion

#line

Se utiliza para cambiar el número de línea y el nombre de archivo en la salida del compilador.

#line 100 "MyFile.cs"
    // The next line will be reported as line 100 in MyFile.cs
    Console.WriteLine("This is line 100");
#line default
    // Line numbering returns to normal

#pragma

Se utiliza para enviar instrucciones especiales al compilador. El uso más común es deshabilitar advertencias específicas.

#pragma warning disable 414
    private int unusedVariable;
#pragma warning restore 414

Consideraciones sobre el uso de directivas de preprocesador

  • Mejorar la legibilidad del código: usar#regionpuede ayudar a separar bloques de código, mejorando la organización del código.
  • Compilación condicional: mediante#ify otras directivas, se puede compilar código diferente en entornos de desarrollo y producción, lo que facilita la depuración y la publicación.
  • Advertencias y errores: mediante#warningy#errorse puede indicar a los desarrolladores en tiempo de compilación que presten atención a problemas específicos.

Al utilizar correctamente estas directivas de preprocesador, se puede controlar mejor el proceso de compilación del código y mejorar la flexibilidad y la mantenibilidad del código.

Otras extensiones