class @class
{
static void @static(bool @bool)
{
if (@bool)
Console.WriteLine("cierto");
else
Console.WriteLine("falso");
}
}
|
Lo que se ha hecho en el código anterior ha sido usar @ para declarar una clase de nombre class con un método de nombre static que toma un parámetro de nombre bool, aún cuando todos estos nombres son palabras reservadas en C#.
Hay que precisar que aunque el nombre que nosotros escribamos sea por ejemplo @class, el nombre con el que el compilador va a tratar internamente al identificador es solamente class. De hecho, si desde código escrito en otro lenguaje adaptado a .NET distinto a C# hacemos referencia a éste identificador y en ese lenguaje su nombre no es una palabra reservada, el nombre con el que deberemos referenciarlo es class, y no @class (si también fuese en ese lenguaje palabra reservada habría que referenciarlo con el mecanismo que el lenguaje incluyese para ello, que quizás también podría consistir en usar @ como en C#)
En realidad, el uso de @ no se tiene porqué limitar a preceder palabras reservadas en C#, sino que podemos preceder cualquier nombre con él. Sin embargo, hacer esto no se recomienda, pues es considerado como un mal hábito de programación y puede provocar errores muy sutiles como el que muestra el siguiente ejemplo:
class A
{
int a; // (1)
int @a; // (2)
public static void Main()
{}
}
|
Si intentamos compilar este código se producirá un error que nos informará de que el campo de nombre a ha sido declarado múltiples veces en la clase A. Esto se debe a que como @ no forma parte en realidad del nombre del identificador al que precede, las declaraciones marcadas con comentarios como (1) y (2) son equivalentes.
Hay que señalar por último una cosa respecto al carácter @: sólo puede preceder al nombre de un identificador, pero no puede estar contenido dentro del mismo. Es decir, identificadores como i5322@fie.us.es no son válidos.
Literales
Un literal es la representación explícita de los valores que pueden tomar los tipos básicos del lenguaje. A continuación se explica cuál es la sintaxis con que se escriben los literales en C# desglosándolos según el tipo de valores que representan:
- Literales enteros: Un número entero se puede representar en C# tanto en formato decimal como hexadecimal. En el primer caso basta escribir los dígitos decimales (0-9) del número unos tras otros, mientras que en el segundo hay que preceder los dígitos hexadecimales (0-9, a-f, A-F) con el prefijo 0x. En ambos casos es posible preceder el número de los operadores + ó – para indicar si es positivo o negativo, aunque si no se pone nada se considerará que es positivo. Ejemplos de literales enteros son 0, 5, +15, -23, 0x1A, -0x1a, etc
En realidad, la sintaxis completa para la escritura de literales enteros también puede incluir un sufijo que indique el tipo de dato entero al que ha de pertenecer el literal. Esto no lo veremos hasta el Tema 7: Variables y tipos de datos.
- Literales reales: Los números reales se escriben de forma similar a los enteros, aunque sólo se pueden escribir en forma decimal y para separar la parte entera de la real usan el tradicional punto decimal (carácter .) También es posible representar los reales en formato científico, usándose para indicar el exponente los caracteres e ó E. Ejemplos de literales reales son 0.0, 5.1, -5.1, +15.21, 3.02e10, 2.02e-2, 98.8E+1, etc.
Al igual que ocurría con los literales enteros, los literales reales también pueden incluir sufijos que indiquen el tipo de dato real al que pertenecen, aunque nuevamente no los veremos hasta el Tema 7: Variables y tipos de datos
- Literales lógicos: Los únicos literales lógicos válidos son true y false, que respectivamente representan los valores lógicos cierto y falso.
- Literales de carácter: Prácticamente cualquier carácter se puede representar encerrándolo entre comillas simples. Por ejemplo, 'a' (letra a), ' ' (carácter de espacio), '?' (símbolo de interrogación), etc. Las únicas excepciones a esto son los caracteres que se muestran en la Tabla 4.1, que han de representarse con secuencias de escape que indiquen su valor como código Unicode o mediante un formato especial tal y como se indica a continuación:
|
Carácter |
Código de escape Unicode |
Código de escape especial |
|
Comilla simple |
\u0027 |
\' |
|
Comilla doble |
\u0022 |
\" |
|
Carácter nulo |
\u0000 |
\0 |
|
Alarma |
\u0007 |
\a |
|
Retroceso |
\u0008 |
\b |
|
Salto de página |
\u000C |
\f |
|
Nueva línea |
\u000A |
\n |
|
Retorno de carro |
\u000D |
\r |
|
Tabulación horizontal |
\u0009 |
\t |
|
Tabulación vertical |
\u000B |
\v |
|
Barra invertida |
\u005C |
\\ |
Tabla 4.1: Códigos de escape especiales
En realidad, de la tabla anterior hay que matizar que el carácter de comilla doble también puede aparecer dentro de un literal de cadena directamente, sin necesidad de usar secuencias de escape. Por tanto, otros ejemplos de literales de carácter válidos serán '\?', '?', '\f', '\u0000', '\\', '\'', etc.
Aparte de para representar los caracteres de la tabla anterior, también es posible usar los códigos de escape Unicode para representar cualquier código Unicode, lo que suele usarse para representar literales de caracteres no incluidos en los teclados estándares.
Junto al formato de representación de códigos de escape Unicode ya visto, C# incluye un formato abreviado para representar estos códigos en los literales de carácter si necesidad de escribir siempre cuatro dígitos aún cuando el código a representar tenga muchos ceros en su parte izquierda. Este formato consiste en preceder el código de \x en vez de \u. De este modo, los literales de carácter ‘\U00000008’, '\u0008', '\x0008', '\x008', '\x08' y '\x8' son todos equivalentes. Hay que tener en cuenta que este formato abreviado sólo es válido en los literales de carácter, y no a la hora de dar nombres a los identificadores.
- Literales de cadena: Una cadena no es más que una secuencia de caracteres encerrados entre comillas dobles. Por ejemplo ?Hola, mundo?, ?camión?, etc. El texto contenido dentro estos literales puede estar formado por cualquier número de literales de carácter concatenados y sin las comillas simples, aunque si incluye comillas dobles éstas han de escribirse usando secuencias de escape porque si no el compilador las interpretaría como el final de la cadena.
Aparte del formato de escritura de literales de cadenas antes comentado, que es el comúnmente utilizado en la mayoría de lenguajes de programación, C# también admite uno nuevo consistente en precederlos de un símbolo @, caso en que todo el contenido de la cadena sería interpretado tal cual, sin considerar la existencia de secuencias de escape. A este tipo de literales se les conoce como literales de cadena planos o literales verbatim y pueden incluso ocupar varias líneas. La siguiente tabla recoge algunos ejemplos de cómo se interpretan:
|
Literal de cadena |
Interpretado como... |
|
?Hola\tMundo? |
Hola Mundo |
|
@”Hola\tMundo? |
Hola\tMundo |
|
@?Hola
Mundo? |
Hola
Mundo |
|
@”””Hola Mundo””" |
“Hola Mundo” |
Tabla 4.2: Ejemplos de literales de cadena planos
El último ejemplo de la tabla se ha aprovechado para mostrar que si dentro de un literal de cadena plano se desea incluir caracteres de comilla doble sin que sean confundidos con el final de la cadena basta duplicarlos.
- Literal nulo: El literal nulo es un valor especial que se representa en C# con la palabra reservada null y se usa como valor de las variables de objeto no inicializadas para así indicar que contienen referencias nulas.