Autor en Google+
Saltar al contenido

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript... y lo que venga ;)

16 años online

el blog de José M. Aguilar

Inicio El autor Contactar

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web
ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript...

¡Microsoft MVP!
martes, 22 de febrero de 2022
Compartir:
.NET

Aún no hemos terminado de asimilar las novedades de C# 10, cuando ya empiezan a llegar noticias de lo que encontraremos en la próxima versión, C# 11, que si todo va bien se lanzará en noviembre de este año.

Una de las que más me ha llamado la atención de momento es la llegada de raw string literals, una característica que mejorará bastante la posibilidad de escribir constantes de cadena multilínea en nuestro código.

Veamos en qué consiste.

Disclaimer: la nueva versión de C# está aún en desarrollo, y detalles de los que veamos aquí podrían cambiar antes de lanzarse definitivamente.

Antes de C#11: Verbatim string literals

Como recordaréis, hasta C# 10 la forma más cómoda de escribir este tipo de literales era utilizando el prefijo arroba "@", como en el siguiente ejemplo:

var str = 
    @"<div>
          <button>Click here!</button>
      </div>";
Console.WriteLine(str);            

Aunque es bastante mejor que no tener nada, este enfoque presenta algunos problemillas.

Por ejemplo, uno de ellos eran las indentaciones. Dado que indentar es algo que solemos hacer para mejorar la legibilidad del código, era habitual que estas cadenas salieran "descuadradas" a la hora de ser mostradas. Por ejemplo, si ejecutásemos el código anterior, veríamos lo siguiente por consola:

<div>
          <button>Click here!</button>
      </div>

Otro problema es que la constante de cadena está delimitada por comillas dobles. Por ello, si en su interior quisiéramos utilizar este mismo carácter nos veíamos obligados a escaparlo usando dobles-dobles comillas:

var str = 
    @"<div class=""col-3"">
          <button id=""btn"">Click here!</button>
      </div>";
Console.WriteLine(str);            

Obviamente, en algunos casos también podíamos sustituir las comillas dobles por simples al escribir (por ejemplo, en HTML o código JavaScript), pero hay otros escenarios donde esto no es posible, como en una representación JSON, o directamente no es viable ni práctico, como cuando hemos copiado y pegado un contenido largo.

C# 11: Raw string literals

En C# 11 tendremos una forma más potente para escribir estos literales de texto multilínea. Aunque se parecen bastante a las verbatim string literals, en este caso debemos utilizar como delimitador inicial y final un mínimo de tres caracteres doble-comilla (es decir, """), siempre que el número de ambas coincidan.

var str = """
    <div>
        <button>Click here!</button>
    </div>
    """;

El delimitador final debe estar en una línea independiente, excepto si optamos por definir la cadena literal en una única línea:

var xml = """Hello, world!""";

Dado que los delimitadores son claramente identificables, ya podríamos insertar comillas en su interior sin problema:

var str = """
    <div class="col-3">
        <button id="btn">Click here!</button>
    </div>
    """;

Seguro que ya entendéis por qué son un mínimo de tres comillas. Esto nos permite abordar sin mucho drama escenarios habituales, como por ejemplo atributos vacíos en un documento HTML:

var str = """
    <div class="">
        <button>Click here!</button>
    </div>
""";

Y también, seguro que os extrañó el hecho de que el número de comillas en los delimitadores inicial y final sea variable; como podemos decidir cuántas usar, si por ejemplo en el interior necesitásemos usar tres comillas, podríamos delimitar la cadena con cuatro:

var str = """"
    Para delimitar los raw string literals 
    podemos usar tres comillas: """
    """";

Otro aspecto muy interesante de los string literals es que se ignorará la indentación del código en el que los insertemos. Es decir, el compilador considerará que el "punto cero" de la indentación es aquél en el que se encuentre el delimitador del final de la cadena.

Por ejemplo:

Console.WriteLine("--- Start");
var str = """
       <div>
           <button>Click here!</button>
       </div>
       """;
Console.WriteLine(str);  
Console.WriteLine("--- End");

El resultado será:

--- Start
<div>
   <button>Click here!</button>
</div>
--- End

Por tanto, las siguientes cadenas son equivalentes:

var str1 = """
    if(value) {
        alert("Hi!");
    }
    """;
        
var str2 = """
                if(value) {
                    alert("Hi!");
                }
                """;

Console.WriteLine(str1==str2); // True

También podemos utilizar interpolación con las cadenas literales de la misma forma que siempre, aunque con una pequeña diferencia: tendremos que repetir el prefijo "$" tantas veces como llaves queramos utilizar para introducir expresiones interpoladas:

// Usamos un único carácter, como siempre:
var name = "John";
var str = $"""
    Hola {name}, ¿qué tal?
    """;

// O bien, en este caso sólo se reemplazará "name":
var str = $$"""
    Hola {{name}}, ¿qué tal?
    Me gusta usar llaves para poner {cosas}
    """;

En definitiva, se trata de una característica interesantísima, que nos vendrá de perlas en muchos escenarios, como la definición de strings con XML, HTML, CSS, JSON, JavaScript, SQL... pero eso sí, de momento habrá que esperar unos meses para disfrutar de ella.

Si queréis ver la especificación completa, está disponible en GitHub. Y si os interesa, podéis ir a echar un vistazo a cómo funciona por detrás en Sharplab.io.

Publicado en Variable not found.

Compartir:

1 comentario:

Subgurim dijo...

Se me cae la lagrimilla :_)

Artículos relacionados: