Tutorial C#

 

Como se ha repetido varias veces a lo largo del tema, la principal utilidad del preprocesador en C# es la de permitir la compilación de código condicional, lo que consiste en sólo permitir que se compile determinadas regiones de código fuente si las variables de preprocesado definidas cumplen alguna condición determinada. Para conseguir esto se utiliza el siguiente juego de directivas:

 

            #if <condición1>

                        <código1>

            #elif <condición2>

                        <código2>

            ...

            #else

                        <códigoElse>

            #endif

 

El significado de una estructura como esta es que si se cumple <condición1> entonces se pasa al compilador el <código1>, si no ocurre esto pero se cumple <condición2> entonces lo que se pasaría al compilador sería <código2>, y así continuamente hasta que se llegue a una rama #elif cuya condición se cumpla. Si no se cumple ninguna pero hay una rama #else se pasará al compilador el <códigoElse>, pero si dicha rama no existiese entonces no se le pasaría código alguno y se continuaría preprocesando el código siguiente al #endif en el fuente original.

 

Aunque las ramas #else y #endif son opcionales, hay que tener cuidado y no mezclarlas ya que la rama #else sólo puede aparecer como última rama del bloque #if...#endif.

 

Es posible anidar varias estructuras #if...#endif, como muestra el siguiente código:

 

            #define PRUEBA

 

            using System;

 

            class A

            {

                        public static void Main()

                        {

                                   #if PRUEBA

                                               Console.Write (“Esto es una prueba”);

                                               #if TRAZA

                                                           Console.Write(“ con traza”);

                                               #elif !TRAZA

                                                           Console.Write(“ sin traza”);

                                               #endif

                                   #endif

                        }

            }

 

Como se ve en el ejemplo, las condiciones especificadas son nombres de identificadores de preprocesado, considerándose que cada condición sólo se cumple si el identificador que se indica en ella está definido. O lo que es lo mismo: un identificador de preprocesado vale cierto (true en C#) si está definido y falso (false en C#) si no.

 

El símbolo ! incluido en junto al valor de la directiva #elif es el símbolo de “no” lógico, y el #elif en el que se usa lo que nos permite es indicar que en caso de que no se encuentre definido el identificador de preprocesado TRAZA se han de pasar al compilador las instrucciones a continuación indicadas (o sea, el Console.Write(“sin traza”);)

 

El código fuente que el preprocesador pasará al compilador en caso de que compilemos sin especificar ninguna opción /d en la llamada al compilador será:

 

            using System;

 

            class A

            {

                        public static void Main()

                        {

                                   Console.Write(“Esto es una prueba”);

                                   Console.Write(“ sin traza”);

                        }

            }

           

Nótese como en el código que se pasa al compilador ya no aparece ninguna directiva de preprocesado, pues lo que el preprocesador le pasa es el código resultante de aplicar al original las directivas de preprocesado que contuviese.

 

Asimismo,  si compilásemos el código fuente original llamando al compilador con /d:TRAZA, lo que el preprocesador pasaría al compilador sería:

 

            using System;

 

            class A

            {

                        public static void Main()

                        {

                                   Console.Write (“Esto es una prueba”);

                                   Console.Write(“ sin traza”);

                        }

            }

 

Hasta ahora solo hemos visto que la condición de un #if o #elif puede ser un identificador de preprocesado, y que este valdrá true o false según esté o no definido. Pues bien, estos no son el único tipo de condiciones válidas en C#, sino que también es posible incluir condiciones que contengan expresiones lógicas formadas por identificadores de preprocesado, operadores lógicos (! para “not”, && para “and” y || para “or”), operadores relacionales de igualdad (==) y desigualdad (!=), paréntesis (( y )) y los identificadores especiales true y false. Por ejemplo:

 

            #if TRAZA // Se cumple si TRAZA esta definido.

            #if TRAZA==true // Idem al ejemplo anterior aunque con una sintaxis menos cómoda

            #if !TRAZA // Sólo se cumple si TRAZA no está definido.

            #if TRAZA==false // Idema al ejemplo anterior aunque con una sintaxis menos cómoda

            #if TRAZA == PRUEBA //  Solo se cumple si tanto TRAZA como PRUEBA están                                                           // definidos o si no ninguno lo está.

            #if TRAZA != PRUEBA //  Solo se cumple si TRAZA esta definido y PRUEBA no o                                                          // viceversa

            #if TRAZA && PRUEBA // Solo se cumple si están definidos TRAZA y PRUEBA.

            #if TRAZA || PRUEBA // Solo se cumple si están definidos TRAZA o PRUEBA.

            #if false // Nunca se cumple (por lo que es absurdo ponerlo)

            #if true // Siempre se cumple (por lo que es absurdo ponerlo)

 

Es fácil ver que la causa de la restricción antes comentada de que no es válido dar un como nombre true o false a un identificador de preprocesado se debe al significado especial que estos tienen en las condiciones de los #if y #elif