Atributos de compilación
Aunque la mayoría de los atributos son interpretados en tiempo de ejecución por el CLR u otras aplicaciones, hay una serie de atributos que tienen un significado especial en C# y condicionan el proceso de compilación. Estos son los que se explican a continuación.
Atributo System.AttributeUsage
Ya hemos visto en este mismo tema que se usa para indicar dónde se pueden colocar los nuevos atributos que el programador defina, por lo que no se hará más hincapié en él.
Atributo System.Obsolete
Puede preceder a cualquier elemento de un fichero de código fuente para indicar que ha quedado obsoleto. Admite los siguientes dos parámetros sin nombre:
- Un primer parámetro de tipo string que contenga una cadena con un mensaje a mostrar cuando al compilar se detecte que se ha usado el elemento obsoleto.
- Un segundo parámetro de tipo bool que indique si se ha de producir un aviso o un error cuando se detecte el uso del elemento obsoleto. Por defecto se muestra un aviso, pero si se da valor true a este parámetro, el mensaje será de error.
El siguiente ejemplo muestra como utilizar este atributo:
using System;
class Obsoleta
{
[Obsolete("No usar f(), que está obsoleto.", true)]
public static void f()
{}
public static void Main()
{
f();
}
} |
Cuando se compile este programa, el compilador emitirá el siguiente mensaje de error:
|
obsolete.cs(11,17): error CS0619: ‘Obsoleta.f()’ is obsolete: No usar f(), que está obsoleto.
|
Si no se hubiese especificado a Obsolete su segundo parámetro, entonces el mensaje sería de aviso en vez de error:
|
obsolete.cs(11,17): warning CS0618: ‘Obsoleta.f()’ is obsolete: No usar f(), que está obsoleto.
|
Atributo System.Diagnostics.Conditional
Este atributo sólo puede prefijar definiciones de métodos, y permite definir si las llamadas al método prefijado se han de compilar o no. Puede usarse múltiples veces prefijando a un mismo método y toma un parámetro sin nombre de tipo string. Sólo se compilarán aquellas llamadas al método tales que en el momento de hacerlas esté definida alguna directiva de preprocesado con el mismo nombre que el parámetro de alguno de los atributos Conditional que prefijen la definición de ese método.
Como se ve, este atributo es una buena forma de simplificar la escritura de código que se deba compilar condicionalmente, ya que evita tener varias directivas #if que encierren cada llamada al método cuya ejecución se desea controlar. Sin embargo, Conditional no controla la compilación de ese método, sino sólo las llamadas al mismo.
El siguiente ejemplo muestra cómo usar Conditional:
using System;
using System.Diagnostics;
class Condicional
{
[Conditional("DEBUG")]
public static void F()
{
Console.WriteLine("F()");
}
public static void Main()
{
F();
}
} |
Sólo si compilamos el este código definiendo la constante de preprocesado DEBUG se mostrará por pantalla el mensaje F() En caso contrario, nunca se hará la llamada a F()
Hay que precisar que en realidad Conditional no puede preceder a cualquier definición de método, sino que en su colocación hay impuestas ciertas restricciones especiales:
- El método ha de tener un tipo de retorno void. Esto se debe a que si tuviese otro se podría usar su valor de retorno como operando en expresiones, y cuando no fuesen compiladas sus llamadas esas expresiones podrían no tener sentido y producir errores de compilación.
- Si se aplica a un método virtual todas sus redefiniciones lo heredan, siendo erróneo aplicárselo explícitamente a una de ellas. Esto debe a que en tiempo de compilación puede no saberse cuál es el verdadero tipo de un objeto, y si unas redefiniciones pudiesen ser condicionales y otras no, no podría determinarse al compilar si es condicional la versión del método a la que en cada caso se llame.
- No puede atribuirse a métodos definidos en interfaces ni a implementaciones de métodos de interfaces, pues son también virtuales y podrían reimplementarse.
Atributo System.ClsCompliant
Permite especificar que el compilador ha de asegurarse de que el ensamblado, tipo de dato o miembro al que se aplica es compatible con el CLS. Ello se le indica (ya sea por nombre o posicionalmente) a través de su único parámetro bool IsCompliant, tal y como se muestra en el siguiente código ejemplo:
using System;
[assembly:CLSCompliant(true)]
public class A
{
public void F(uint x)
{}
public static void Main()
{}
}
|
Si intenta compilarlo tal cual, obtendrá el siguiente mensaje de error:
|
error CS3001: El tipo de argumento 'uint' no es compatible con CLS |
Esto se debe a que el tipo uint no forma parte del CLS, y en el código se está utilizando como parte de un método público aún cuando mediante el atributo CLSCompliant se está indicando que se desea que el código sea compatible con el CLS. Si se le quitase este atributo, o se diese el valor false a su parámetro, o se definiesen la clase A o el método F() como privados, o se cambiase el tipo del parámetro x a un tipo perteneciente al CLS (pe, int), entonces sí que compilaría el código.
Nótese que cuando el atributo CLSCompliant se aplica a nivel de todo un ensamblado, se comprueba la adecuación al CLS de todos sus tipos de datos, mientras que si solamente se aplica a un tipo de dato, sólo se comprobará la adecuación al CLS del mismo; y si tan sólo se aplica a un miembro, únicamente se comprobará la adecuación al CLS de éste.