Muchos lenguajes permiten de forma directa la introducción de cadenas de texto de más de una línea, y C# no iba a ser menos. En este artículo veremos cómo conseguir utilizando el prefijo arroba (@) en cadenas de texto.

Todo lo que te voy a explicar en este artículo lo vengo tratando en diversos post de mi blog VariableNotFound y que ahora reúno en un completo artículo para el Manual de .NET de DesarrolloWeb.com.

Siempre he envidiado a los desarrolladores PHP, Ruby o a las figuras del shell-scripting por poder utilizar heredoc para representar cadenas de caracteres de longitud considerable.

Por si no te habías encontrado antes con este término, heredoc es una forma de escribir cadenas literales de forma directa, sin preocuparse de caracteres de control, secuencias de escape o saltos de línea de forma manual. Simplemente se indica en el comienzo la marca que permitirá identificar su final y el resultado será el conjunto de caracteres contenidos entre el inicio y la marca, todo incluido.

De hecho, Heredoc es una abreviatura de "Here document", que viene a ser algo así como "documento a continuación".

Un ejemplo para enviar al navegador del cliente una porción de código script correctamente formateado sería el que se muestra a continuación. Se puede distinguir la marca de comienzo (<<<) seguida de la etiqueta que se usará para determinar su finalización (EOT); a continuación va el contenido del literal y, por último, la marca asignada al comienzo (EOT):

<?php
echo <<<EOT
function AddCss()
{
      var l=document.createElement('link');
      l.setAttribute('type','text/css');
     l.setAttribute('rel','stylesheet');
      l.setAttribute('href','styles.css');
      document.getElementsByTagName('head')[0].appendChild(l);
};
EOT;
?>

Sin embargo, y aquí va la buena noticia, resulta que en C# podemos realizar algo bastante parecido precediendo la cadena por el carácter "@" (arroba), de la siguiente forma:

string script =
@"function AddCss()
{
      var l=document.createElement('link');
      l.setAttribute('type','text/css');
      l.setAttribute('rel','stylesheet');
      l.setAttribute('href','styles.css');
      l.setAttribute('media','screen');
      document.getElementsByTagName('head')[0].appendChild(l);
}";
Response.Write(script);

Su principal ventaja es la capacidad de representar texto estructurado como Javascript, CSS, (X)HTML, XML o SQL de forma muy directa, ya véis el ejemplo anterior. Nada de "trocear" la cadena en líneas e ir concatenando, ni de introducir caracteres de escape para saltos de línea o tabulaciones. Todo un gustazo, y la legibilidad que aporta el código es increíble.

Por citar algún inconveniente, la cadena siempre debe acabar en dobles comillas; por tanto, si queremos usar este carácter debemos introducirlo doblemente (por ejemplo ""hola"" en vez de "hola"). Tampoco se realiza sustitución de variables en su interior (como ocurre, por ejemplo, en PHP), por lo que hay que usar los operadores de concatenación.

De todas formas, un detalle importante es que para concatenar cadenas definidas de esta manera hay que utilizar la arroba en cada una de las subcadenas constantes. A continuación se muestra un ejemplo en C# donde se pretende incluir el valor de la variable "number" en una sentencia SQL:

string sql =
@"SELECT product_name,
      product_details,
      total_rows
FROM (
            SELECT product_name,
                  product_number,
                  product_details,
                  total_rows,
                  rownum row_counter
            FROM (
                  SELECT product_name,
                        product_details,
                        count(*) OVER () total_rows
                  FROM products
                  WHERE product_number = " + number + @"
                  ORDER BY product_name
            )
      )
WHERE row_counter between v_start_row and v_end_row;";

Sé que el ejemplo no es muy correcto desde el punto de vista de la construcción de la sentencia SQL (podría ser vulnerable a inyección SQL), pero creo que ilustra perfectamente la forma de incluir un contenido variable en el interior de una cadena de este tipo.

Aunque no está relacionado directamente con lo tratado en este artículo, aprovecho la ocasión para comentar otra utilidad del carácter arroba "@" en C#. Además de permitir la definición de constantes string literales y multilíneas, también puede ser utilizado para utilizar nombres reservados del lenguaje como identificadores.

Segun las especificación del lenguaje C#, un identificador (de una variable, clase, propiedad...) puede ser una de las palabras clave del lenguaje (for, if, int, string...) si va precedida por una arroba, permitiendo aberraciones como la siguiente:

class @class
{
      public static void @static(bool @bool)
      {
            if (@bool)
                  System.Console.WriteLine("true");
            else
                  System.Console.WriteLine("false");
      }
}

En definitiva, no es algo que se utilice con demasiada frecuencia, pero está bien saber que existe esta posibilidad.