En los dos primeros artículos, de esta serie de tres sobre Razor, publicados en el Manual de WebMatrix, aprendimos aspectos fundamentales como sus objetivos, la forma de crear un primer “Hola Mundo”, la relación que tiene con la Programación Orientada a Objetos y la forma en que se crean variables y cadenas.

En este artículo nos centraremos en otros tres aspectos clave: la forma en que se gestiona la toma de decisiones, la ejecución de bucles y el uso de colecciones de valores.

Toma de decisiones en Razor

Existen varios operadores en Razor tanto para definir distintos flujos de ejecución en función de una condición lógica. Existe un tipo concreto conocido como “bool” que nos sirve para definir variables que sólo podrán contener uno de estos dos valores: verdadero o falso. En el siguiente fragmento de código podemos ver un ejemplo:

@{
bool resultado = miObjeto.HaSidoExitoso();
if (resultado == true)
{
<h1>Ha salido bien.</h1>
}
else
{
<h1>Ha fallado.</h1>
}
}

Analicemos el fragmento. En primer lugar recogemos en la variable “resultado” lo que nos devuelve el método “HaSidoExitoso” de un objeto “miObjeto”. Este resultado, al estar almacenado en una variable booleana, sólo puede ser verdadero o falso.

A partir de ahí, utilizando el operador de decisión if/else, podemos mostrar en el HTML final dos posibles mensajes: uno si el resultado ha sido exitoso (valor “true”) y otro si el resultado ha fallado (valor contrario, “false”).

Existe otro operador de decisión, llamado switch, que nos facilitar trabajar con rangos de opciones. Por ejemplo, si el valor de un resultado es un entero de entre 1 y 3, y queremos ejecutar sentencias distintas para cada caso, podríamos definir tres etiquetas “case” para cada uno de esos tres valores. El siguiente ejemplo nos aclara cómo hacerlo.

@{
int resultado = miObjeto.OtroMetodo();
switch (resultado)
{
case 1: // Codigo para el resultado igual a 1
break;

case 2: // Codigo para el resultado igual a 2
break;

case 3: // Codigo para el resultado igual a 3
break;

default: // Codigo para resultado distinto de 1, 2 y 3
break;
}
}

Como vemos, por cada posible valor del resultado definimos una etiqueta case con el valor que aplica. Estas etiquetas se cierran con la instrucción break y contendrán todas las instrucciones que queremos ejecutar para ese caso. En el ejemplo, sin embargo, nos hemos limitado a definir unos cuantos comentarios (que nunca aparecerán en el HTML devuelto al cliente, al igual que todo el código que se ejecuta en el servidor).

Por último, la etiqueta “default” nos sirve para definir un caso por defecto en caso de que el valor de la variable sobre la que se ejecuta el switch, sea distinto a todos los considerados. Suele servir, en la mayoría de casos, para realizar control de errores.

Bucles y colecciones en la sintaxis de Razor

En cuanto a los bucles, en un artículo anterior hablábamos sobre clases y objetos. Vamos a introducir un nuevo concepto: las colecciones. No son más que lo que su propio nombre indica, colecciones u estructuras de datos que contienen múltiples objetos de un mismo tipo. Es decir, que una colección podrá serlo de enteros, de booleanos, de cadenas de texto, pero no podrá serlo de varios tipos a la vez.

Será frecuente que queramos ejecutar instrucciones repetidas sobre todos los objetos que forman parte de una colección. Por ejemplo, si el resultado de un método es una colección de enteros con las edades de los usuarios de una página y queremos mostrar por pantalla dichos valores, lo más práctico es iterar por esta colección de elementos y, para cada uno, generar el mismo fragmento HTML para visualizar su valor por pantalla. El operador principal para lograr esto es “for”. Veamos un ejemplo:

@{
int[] coleccion = new int[] { 1, 2, 3, 4 };
for (int i=0; i<coleccion.Length; i++)
{
<h1>Numero @coleccion[i]</h1>
}
}

Como se puede ver en el código, en primer lugar se define una colección de enteros del 1 al 4. Esto se hace creando una variable “colección” cuyo tipo será “int[]”. Es importante indicar que, en C# (y por ende en Razor), podemos crear una colección o array de cualquier tipo situando los caracteres [] tras el tipo, como en este ejemplo.

Una vez creada la colección, la recorreremos con el operador for. Para ello, necesitamos una variable contador, que nos permite saber en qué posición de la colección nos encontramos. Desde los tiempos de C, 40 años atrás, i ha sido el nombre más popular para este tipo de variables (seguido de j, k, l, etc.), así que sigamos la tradición.

Una vez definida la variable, tenemos que indicar el límite del bucle con una sentencia lógica. En este caso estamos accediendo a la propiedad “Length” de la colección (no olvidemos que todo son objetos y los objetos tienen propiedades con valores que les definen, como el número de elementos en este caso).

La última cláusula sirve para indicar cuantos avances queremos en nuestra variable contadora al finalizar cada iteración del bucle (el operador ++ nos sirve para indicarle que sólo uno). Resumiendo, el bucle entero se leería, en lenguaje natural, así:

“Define una variable contador i con valor inicial 0, que no puede ser mayor que el número de elementos de la colección, y que avanza una posición en cada iteración”

Posteriormente, con el bloque de llaves definimos el código que queremos ejecutar en cada iteración del bucle. En este caso lo que estamos haciendo es, para cada iteración, acceder a un elemento de la colección. Para ello utilizamos la sintaxis siguiente:

Nombre_Variable_Coleccion[Variable_Contador];

Con esta sintaxis lo que estamos haciendo es acceder a un de los elementos que compone la colección; en concreto, al elemento que ocupa la posición representada por el valor de la variable contador. Como es habitual, el primero de los elementos de la colección ocupa la posición 0. El resultado del fragmento de código que hemos visto sería una imagen parecida a la siguiente.

Existen otros operadores de bucle, como While y Foreach, que dejaremos para investigación del lector en los enlaces que se proveen en la sección de Bibliografía.

Conclusiones

Con este artículo terminamos la serie relacionada con Razor, tras ver cómo se gestionan bucles, colecciones y operadores para la toma de decisiones. A lo largo de la serie hemos visto la sintaxis, estructuras y operadores principales de Razor, suficiente como para poder trabajar en la mayoría de aplicaciones web sin problemas. Para aquellos que ya hayan trabajado con ASP.NET y C# la sintaxis resulta tremendamente familiar.

Y para aquellos que ya tengan un cierto bagaje con lenguajes que sigan los principios de C, como C++, Java o PHP, no debería resultar excesivamente dificultoso.

Por último, para los que prefieran VB.NET, es importante destacar que también es posible trabajar con Razor y este lenguaje de programación.