Fundamentos de C#

Comentarios

    Un comentario es texto que se incluye en el código fuente para facilitarsu lectura a los programadores y cuyo contenido es, por defecto, completamenteignorado por el compilador. Suelen usarse para incluir información sobre elautor del código, para aclarar el significado o el porqué de determinadassecciones de código, para describir el funcionamiento de los métodos de lasclases, etc.

    En C# hay dos formas de escribir comentarios. La primera consiste en encerrar todo el texto que se desee comentar entre caracteres /* y */ . Estos comentarios pueden abarcar tantas líneas como sea necesario. Porejemplo:


/* Texto */

/* Esto es un comentario que ejemplifica cómo se escribe
comentarios que ocupen varias líneas*/ 

   Ahora bien, hay quetener cuidado con el hecho de que no es posible anidar comentarios de este tipo. Es decir, no vale escribir comentarios como el siguiente:

NO ES CORRECTO!
/* Comentario contenedor /* Comentario contenido */  */

    Esto se debe a que como el compilador ignora todo el texto contenido en un comentario y sólo busca la secuencia */ que marca su final, ignorará el segundo /* y cuando llegue al primer */ considerará que ha acabado el comentario abierto con el primer /* (no el abierto con el segundo) y pasará a buscar código. Como el */ sólo lo admite si ha detectado antes algún comentario abierto y aún no cerrado (no mientras busca código), cuando llegue al segundo */ considerará que ha habido un error ya que encontrará el */ donde esperaba encontrar código

    Dado que muchas veces los comentarios que se escriben son muy cortos y no suelen ocupar más de una línea, C# ofrece una sintaxis alternativa más compacta para la escritura este tipo de comentarios en las que se considera como indicador del comienzo del comentario la pareja de caracteres // y como indicador de su final el fin de línea. Por tanto, la sintaxis que siguen estos comentarios es:


// <texto>
          
    Y un ejemplo de su uso es: 


// Este comentario ejemplifica como escribir comentarios de una sola línea

    Estos comentarios de una sola línea sí que pueden anidarse sin ningún problema. Por ejemplo, el siguiente  comentario es perfectamente válido:


// Comentario contenedor // Comentario contenido
                 

Identificadores

    Al igual que en cualquier lenguaje de programación, en C# un identificador no es más que, como su propio nombre indica, un nombre con el que identificaremos algún elemento de nuestro código, ya sea una clase, una variable, un método, etc.

    Típicamente el nombre de un identificador será una secuencia de cualquier número de caracteres alfanuméricos –incluidas vocales acentuadas y eñes- tales que el primero de ellos no sea un número. Por ejemplo, identificadores válidos serían: Arriba, caña, C3P0, áëÎò, etc; pero no lo serían 3com, 127, etc.

    Sin embargo, y aunque por motivos de legibilidad del código no se recomienda, C# también permite incluir dentro de un identificador caracteres especiales imprimibles tales como símbolos de diéresis, subrayados, etc. siempre y cuando estos no tengan un significado especial dentro del lenguaje. Por ejemplo, también serían identificadores válidos, _barco_, c¨k y A·B; pero no C# (# indica inicio de directiva de preprocesado) o a!b (! indica operación lógica “not”) 

    Finalmente, C# da la posibilidad de poder escribir identificadores que incluyan caracteres Unicode que no se puedan imprimir usando el teclado de la máquina del programador o que no sean directamente válidos debido a que tengan un significado especial en el lenguaje. Para ello, lo que permite es escribir estos caracteres usando secuencias de escape, que no son más que secuencias de caracteres con las sintaxis:

            \u<dígito><dígito><dígito><dígito>

ó          \U<dígito><dígito><dígito><dígito><dígito><dígito><dígito><dígito>

    Estos dígitos indican es el código Unicode del carácter que se desea incluir como parte del identificador, y cada uno de ellos ha de ser un dígito hexadecimal válido. (0-9, a-f ó A-F) Hay que señalar que el carácter u ha de escribise en minúscula cuando se indiquen caracteres Unicode con 4 dígitos y en mayúscula cuando se indiquen con caracteres  de ocho. Ejemplos de identificadores válidos son C\u0064 (equivale a C#, pues 64 es el código de # en Unicode) ó a\U00000033b (equivale a a!b)

Palabras reservadas

    Aunque antes se han dado una serie de restricciones sobre cuáles son los nombres válidos que se pueden dar en C# a los identificadores, falta todavía por dar una: los siguientes nombres no son válidos como identificadores ya que tienen un significado especial en el lenguaje:


abstract, as, base,
bool, break, byte, case,
catch, char, checked, class, const, continue,
decimal, default, delegate, do, double,
else, enum, event, explicit, extern,        
false, finally, fixed, float, for, foreach,
goto,
if, implicit, in, int, interface, internal, is,
lock, long,
namespace, new, null,
object, operator, out, override,
params, private,protected, public,
readonly, ref, return,
sbyte, sealed, short, sizeof, stackalloc, static, string, struct, switch,
this, throw, true, try, typeof,
uint, ulong, unchecked, unsafe, ushort, using,
virtual, void, while
          
    Aparte de estas palabras reservadas, si en futuras implementaciones del lenguaje se decidiese incluir nuevas palabras reservadas, Microsoft dice que dichas palabras habrían de incluir al menos dos símbolos de subrayado consecutivos (__) Por tanto, para evitar posibles conflictos futuros no se recomienda dar a nuestros identificadores nombres que contengan dicha secuencia de símbolos.

    Aunque directamente no podemos dar estos nombres a nuestros identificadores, C# proporciona un mecanismo para hacerlo indirectamente y de una forma mucho más legible que usando secuencias de escape. Este mecanismo consiste en usar el carácter @  para prefijar el nombre coincidente con el de una palabra reservada que queramos dar a nuestra variable. Por ejemplo, el siguiente código es válido:


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.
Fundamentos de C#
José Antonio González Seco

José Antonio es experto en tecnologias Microsoft. Imparte cursos y conferencias en congresos sobre C# y .NET en Universidades de toda España (Sevilla, Barcelona, San Sebastián, Valencia, Oviedo, etc.) en representación de grandes empresas como Microsoft.
Fecha de alta:03/10/2006
Última actualizacion:03/10/2006
Visitas totales:88085
Valorar el contenido:
Últimas consultas realizadas en los foros
Últimas preguntas sin contestar en los foros de devjoker.com