c# - before - ¿Qué significa $ antes de una cadena?

string methods c#

Question

Iba a usar una cadena literal pero escribí por error $ lugar de @ .

Pero el compilador no me dio ningún error y compiló con éxito.

Quiero saber qué es y qué hace. Lo busqué pero no pude encontrar nada.

Sin embargo, no es como una cadena literal porque no puedo escribir:

string str = $"text/";

¿Alguien sabe qué significa $ before string en C #?

string str = $"text";

Estoy usando Visual studio 2015 CTP.

Answer 1

Característica genial. Solo quiero señalar el énfasis en por qué esto es mejor que string.format si no es evidente para algunas personas.

Leí a alguien diciendo orden string.format a "{0} {1} {2}" para que coincida con los parámetros. No está obligado a ordenar "{0} {1} {2}" en string.format, también puede hacer "{2} {0} {1}". Sin embargo, si tiene muchos parámetros, como 20, realmente desea secuenciar la cadena a "{0} {1} {2} ... {19}". Si se trata de un desorden aleatorio, tendrá dificultades para alinear sus parámetros.

Con $, puede agregar parámetros en línea sin contar sus parámetros. Esto hace que el código sea mucho más fácil de leer y mantener.

La desventaja de $ es que no puede repetir el parámetro en la cadena fácilmente, debe escribirlo. Por ejemplo, si está cansado de escribir System.Environment.NewLine, puede hacer string.format ("... {0} ... {0} ... {0}", System.Environment.NewLine), pero, en $, tienes que repetirlo. No puede hacer $ "{0}" y pasarlo a string.format porque $ "{0}" devuelve "0".

En la nota al margen, he leído un comentario en otra publicación duplicada. No pude comentar, así que aquí está. Dijo que

string msg = n + " sheep, " + m + " chickens";

crea más de una cadena de objetos. Esto no es cierto en realidad. Si hace esto en una sola línea, solo crea una cadena y se coloca en el caché de cadenas.

1) string + string + string + string;
2) string.format()
3) stringBuilder.ToString()
4) $""

Todos ellos devuelven una cadena y solo crean un valor en el caché.

Por otra parte:

string+= string2;
string+= string2;
string+= string2;
string+= string2;

Crea 4 valores diferentes en el caché porque hay 4 ";".

Por lo tanto, será más fácil escribir código como el siguiente, pero crearía cinco cadenas interpoladas a medida que Carlos Muñoz corrigiera:

string msg = $"Hello this is {myName}, " +
  $"My phone number {myPhone}, " +
  $"My email {myEmail}, " +
  $"My address {myAddress}, and " +
  $"My preference {myPreference}.";

Esto crea una sola cadena en el caché mientras tiene un código muy fácil de leer. No estoy seguro del rendimiento, pero estoy seguro de que MS lo optimizará si aún no lo está haciendo.

Answer 2

Crea una cadena interpolada .

De MSDN

Usado para construir cadenas. Una expresión de cadena interpolada se parece a una cadena de plantilla que contiene expresiones. Una expresión de cadena interpolada crea una cadena al reemplazar las expresiones contenidas con las representaciones ToString de los resultados de las expresiones.

ex:

 var name = "Sam";
 var msg = $"hello, {name}";

 Console.WriteLine(msg); // hello, Sam

Puedes usar expresiones dentro de la cadena interpolada

 var msg = $"hello, {name.ToLower()}";
 Console.WriteLine(msg); // hello, sam

Lo bueno de esto es que no necesita preocuparse por el orden de los parámetros como lo hace con String.Format .

  var s = String.Format("{0},{1},{2}...{88}",p0,p1,..,p88);

Ahora, si desea eliminar algunos parámetros, debe ir y actualizar todos los recuentos, lo cual ya no es el caso.

Tenga en cuenta que el buen string.format antiguo string.format siendo relevante si desea especificar información cultural en su formatting .

Answer 3

El siguiente ejemplo resalta varias ventajas de usar cadenas interpoladas sobre string.Format() en cuanto a limpieza y legibilidad. También muestra que el código dentro de {} se evalúa como cualquier otro argumento de función, tal como lo haría si se string.Format() .

Console.WriteLine($"I can tab like {"this !", 5}.");

Answer 4

Es más conveniente que string.Format y puede usar intellisense aquí también.

Y aquí está mi método de prueba:

[TestMethod]
public void StringMethodsTest_DollarSign()
{
    string name = "Forrest";
    string surname = "Gump";
    int year = 3; 
    string sDollarSign = $"My name is {name} {surname} and once I run more than {year} years."; 
    string expectedResult = "My name is Forrest Gump and once I run more than 3 years."; 
    Assert.AreEqual(expectedResult, sDollarSign);
}

Answer 5

La sintaxis de $ es buena, pero con un inconveniente.

Si necesita algo como una plantilla de cadena, que se declara en el nivel de clase como campo ... bueno, en un lugar como debería ser.

Luego tienes que declarar las variables en el mismo nivel ... lo cual no es realmente genial.

Es mucho mejor usar la cadena. Sintaxis de formato para este tipo de cosas

using System;

public class Example
{
   public static void Main()
   {
      var name = "Horace";
      var age = 34;
      // replaces {name} with the value of name, "Horace"
      var s1 = $"He asked, /"Is your name {name}?/", but didn''t wait for a reply.";
      Console.WriteLine(s1);

      // as age is an integer, we can use ":D3" to denote that
      // it should have leading zeroes and be 3 characters long
      // see https://docs.microsoft.com/en-us/dotnet/standard/base-types/how-to-pad-a-number-with-leading-zeros
      //
      // (age == 1 ? "" : "s") uses the ternary operator to 
      // decide the value used in the placeholder, the same 
      // as if it had been placed as an argument of string.Format
      //
      // finally, it shows that you can actually have quoted strings within strings
      // e.g. $"outer { "inner" } string"
      var s2 = $"{name} is {age:D3} year{(age == 1 ? "" : "s")} old.";
      Console.WriteLine(s2); 
   }
}
// The example displays the following output:
//       He asked, "Is your name Horace?", but didn''t wait for a reply.
//       Horace is 034 years old.

El uso de globals no está realmente bien y además de eso, tampoco funciona con globals

class Example1_StringFormat {
 string template = $"{0} - {1}";

 public string FormatExample1() {
   string some1 = "someone";
   return string.Format(template, some1, "inplacesomethingelse");
 }

 public string FormatExample2() {
   string some2 = "someoneelse";
   string thing2 = "somethingelse";
   return string.Format(template, some2, thing2);
 }
}

Answer 6

No sé cómo funciona, ¡pero también puedes usarlo para tabular tus valores!

Ejemplo:

 static class Example2_Format {
 //must have declaration in same scope
 static string some = "";
 static string thing = "";
 static string template = $"{some} - {thing}";

//This returns " - " and not "someone - something" as you would maybe 
//expect
 public static string FormatExample1() {
   some = "someone";
   thing = "something";
   return template;
 }

//This returns " - " and not "someoneelse- somethingelse" as you would 
//maybe expect
 public static string FormatExample2() {
   some = "someoneelse";
   thing = "somethingelse";
   return template;
 }
}

Por supuesto, puede reemplazar "esto!" con cualquier variable o algo significativo, así como también puedes cambiar la pestaña.

Answer 7

Se trata de cadenas interpoladas . Puede usar una cadena interpolada en cualquier lugar donde pueda usar un literal de cadena. Cuando ejecute su programa ejecutaría el código con el literal de cadena interpolado, el código calcula un nuevo literal de cadena al evaluar las expresiones de interpolación. Este cálculo ocurre cada vez que se ejecuta el código con la cadena interpolada.

var message = $"Sample, {text}";

Este ejemplo produce un valor de cadena donde se han calculado todos los valores de interpolación de cadena. Es el resultado final y tiene tipo string. Todas las apariciones de llaves dobles (“{{“ and “}}”) se convierten en una llave simple.

Si,

string text = "One";

Entonces el message contiene "Muestra, una".

Console.WriteLine(message); // Sample, One

Ejemplo

public class Person
{
    public String firstName { get; set; }
    public String lastName { get; set; }
}

// Instantiate Person

var person = new Person { firstName = "Albert", lastName = "Einstein" };

// We can print fullname of the above person as follows

Console.WriteLine("Full name - " + person.firstName + " " + person.lastName);
Console.WriteLine("Full name - {0} {1}", person.firstName, person.lastName);
Console.WriteLine($"Full name - {person.firstName} {person.lastName}");

Salida

Full name - Albert Einstein
Full name - Albert Einstein
Full name - Albert Einstein

Referencia - MSDN

Answer 8

Significa interpolación de cadenas.

Lo protegerá porque agrega protección de tiempo de compilación en la evaluación de la cadena.

Ya no obtendrá una excepción con string.Format("{0}{1}",secondParamIsMissing)

Answer 9

Tenga en cuenta que también puede combinar los dos, lo cual es bastante bueno (aunque parece un poco extraño):

// simple interpolated verbatim string
WriteLine($@"Path ""C:/Windows/{file}"" not found.");

Answer 10

el signo $ en la cadena es para la definición de cadena de interpolación que es una característica en C # para interpolar la cadena es una "cadena verdadera" que puede contener expresiones interpoladas

Para obtener más información, esta es la fuente de la respuesta y el ejemplo: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated

Answer 11

$ es una abreviatura de String.Format y se usa con interpolaciones de cadenas, que es una nueva característica de C # 6. Como se usa en su caso, no hace nada, al igual que string.Format() no haría nada.

Se convierte en algo propio cuando se usa para construir cadenas con referencia a otros valores. Lo que antes tenía que escribirse como:

var anInt = 1;
var aBool = true;
var aString = "3";
var formated = string.Format("{0},{1},{2}", anInt, aBool, aString);

Ahora se convierte en:

var anInt = 1;
var aBool = true;
var aString = "3";
var formated = $"{anInt},{aBool},{aString}";

También hay una forma alternativa, menos conocida, de interpolación de cadenas usando $@ (el orden de los dos símbolos es importante). Permite que las características de una cadena @"" se mezclen con $"" para admitir interpolaciones de cadenas sin la necesidad de // toda la cadena. Entonces las siguientes dos líneas:

var someDir = "a";
Console.WriteLine($@"c:/{someDir}/b/c");

dará salida:

c:/a/b/c