c# - before - ¿Qué se supone que significa $ operador para una cadena?
string methods c# (4)
Entonces, acabo de tener la siguiente conversación con un usuario en la sección de comentarios .
Yo:
Year year = new Year{ State = States.Happy };
Ellos:
eventStream.ReceiveJoke += joke =>
Console.WriteLine($"Pretty nice joke: {joke}, Thanks!!!");
Y, nerdy como soy, me pregunto qué quiso decir con el signo de dólar, pero creo que es demasiado vergonzoso preguntarle.
En resumen, es una buena manera de mejorar la legibilidad del código y reducir su longitud. Es mucho mejor que String.Concat o el operador + porque la interpolación de cadenas se ejecuta solo una vez como String.Format (y en realidad se compila a la String.Format método String.Format ) y puedes leer la expresión de izquierda a derecha.
String.Formaty sus primos son muy versátiles y útiles, pero su uso es un poco torpe y propenso a errores. Particularmente desafortunado es el uso de marcadores de posición{0}etc. en la cadena de formato, que debe alinearse con los argumentos proporcionados por separado:
var s = String.Format("{0} is {1} year{{s}} old", p.Name, p.Age);La interpolación de cadenas le permite colocar las expresiones en su lugar, al tener "agujeros" directamente en el literal de cadena:
var s = $"{p.Name} is {p.Age} year{{s}} old";Al igual que con
String.Format, se pueden dar especificadores de alineación y formato opcionales:
var s = $"{p.Name,20} is {p.Age:D3} year{{s}} old";El contenido de los orificios puede ser prácticamente cualquier expresión, incluso otras cadenas:
var s = $"{p.Name} is {p.Age} year{(p.Age == 1 ? "" : "s")} old";Observe que la expresión condicional está entre paréntesis, de modo que la "s" no se confunda con un especificador de formato.
Es el símbolo que le permite crear una cadena interpolada, es una nueva característica de C # 6, y me encanta.
También es un azúcar de sintaxis, explicaré lo que significa al final.
Vamos a ver en acción. mira el siguiente código
public string Receive(int value)
{
return String.Format("Received: {0}", value);
}
public string Receive6(int value)
{
return $"Received: {value}";
}
Lo que pasa lo que se compila.
Tendrán la misma implementación de IL, consulte aquí el IL (en modo de depuración, no optimizado) desde Recibir
.method public hidebysig instance string Receive (int32 ''value'') cil managed
{
// Method begins at RVA 0x22d4
// Code size 22 (0x16)
.maxstack 2
.locals init (
[0] string
)
IL_0000: nop
IL_0001: ldstr "Received: {0}"
IL_0006: ldarg.1
IL_0007: box [mscorlib]System.Int32
IL_000c: call string [mscorlib]System.String::Format(string, object)
IL_0011: stloc.0
IL_0012: br.s IL_0014
IL_0014: ldloc.0
IL_0015: ret
} // end of method Program::Receive
Ahora veamos IL (en modo de depuración, no optimizado) de Receive6
.method public hidebysig instance string Receive6 (int32 ''value'') cil managed
{
// Method begins at RVA 0x22f8
// Code size 22 (0x16)
.maxstack 2
.locals init (
[0] string
)
IL_0000: nop
IL_0001: ldstr "Received: {0}"
IL_0006: ldarg.1
IL_0007: box [mscorlib]System.Int32
IL_000c: call string [mscorlib]System.String::Format(string, object)
IL_0011: stloc.0
IL_0012: br.s IL_0014
IL_0014: ldloc.0
IL_0015: ret
} // end of method Program::Receive6
Como puedes ver con tus propios ojos, el IL es casi lo mismo.
Ahora entendamos lo que es una sintaxis suggar.
En ciencias de la computación, el azúcar sintáctico es una sintaxis dentro de un lenguaje de programación que está diseñado para hacer las cosas más fáciles de leer o expresar. Hace que el lenguaje sea "más dulce" para el uso humano: las cosas se pueden expresar de manera más clara, más concisa o en un estilo alternativo que algunos puedan preferir.
Desde https://en.wikipedia.org/wiki/Syntactic_sugar
Entonces, en lugar de escribir la string.Format masiva. string.Format , use la interpolación de la cadena, el compilador trabajará para usted y convertirá la sintaxis que escribió, en otro código, en este caso, usando la string.Format .
¿Puedo usar opciones de formato como en string.Format?
Sí, puedes, mira abajo.
public static string Receive(int value)
=> string.Format("Received: {0, 15:C}", value);
public static string Receive6(int value)
=> $"Received: {value,15:C}";
Console.WriteLine(Receive(1));
Console.WriteLine(Receive6(1));
Console.WriteLine($"Current data: {DateTime.Now: MM/dd/yyyy}")
Salida (mi cultura es pt-br)
Received: R$ 1,00
Received: R$ 1,00
Current data: 01/01/2016
Obs .: Me gustaría mencionar que no hay diferencia de rendimiento, ya que el uso de interpolación de cadenas e cadenas. El formato es exactamente lo mismo
Es una cadena literal interpolada, introducida en C # 6.
Es ampliamente equivalente a:
eventStream.ReceiveJoke += joke =>
Console.WriteLine(string.Format("Pretty nice joke: {0}, Thanks!!!", joke));
El compilador busca llaves dentro de cualquier cadena literal introducida con $ , y le aplica un formato de cadena. Puede usar (en su mayoría) expresiones arbitrarias, en lugar de solo variables, por ejemplo,
Console.WriteLine($"{year.State} {2000 + 16}"); // Happy 2016
Esta es una nueva característica de C # 6 que se llama interpolación de cadenas, que
le permite más fácilmente formatear cadenas. String.Format y sus primos son muy versátiles, pero su uso es un tanto torpe y propenso a errores.
Para más información sobre esto, por favor eche un vistazo here .
Ejemplo
Dejemos que tengamos la siguiente clase:
public class Customer
{
public int Id { get; set; }
public string FirstName {get; set;}
public string LastName { get; set; }
}
y supongamos que queremos dejar de lado el método ToString , como a continuación:
public override string ToString()
{
return string.Format("The customer with Id: {0} has as FirstName: {1} and as LastName: {2}", Id, FirstName,
LastName);
}
En C # 6 podríamos tener el mismo resultado usando interpolación de cadenas.
public override string ToString()
{
return $"The customer with Id: {Id} has as FirstName: {FirstName} and as LastName: {LastName}";
}
Beneficios de la interpolación de cuerdas:
- Una cadena es significativamente más fácil de leer que una cadena compuesta.
- Hay una reducción en los errores de sintaxis causados por los argumentos que siguen a la cadena de formato que están en un orden incorrecto, o que faltan por completo y causan una excepción.