it-swarm.com.de

Was bedeutet $ vor einem String?

Ich wollte verbatim string verwenden, aber ich habe versehentlich $ statt @ eingegeben.

Der Compiler hat mir jedoch keinen Fehler gemeldet und erfolgreich kompiliert.

Ich möchte wissen, was es ist und was es tut. Ich habe danach gesucht, aber nichts gefunden.

Es ist jedoch keine verbatim-Zeichenfolge, da ich nicht schreiben kann:

string str = $"text\";

Weiß jemand, was $ vor der Zeichenfolge in C # steht.

string str = $"text";

Ich verwende Visual Studio 2015 CTP.

215
M.kazem Akhgary

$ ist eine Abkürzung für String.Format und wird bei String-Interpolationen verwendet. Dies ist eine neue Funktion von C # 6. Wie in Ihrem Fall verwendet es nichts, genauso wie string.Format() nichts tun würde.

Es ist besonders geeignet, wenn es zum Erstellen von Zeichenfolgen mit Bezug auf andere Werte verwendet wird. Was zuvor geschrieben werden musste:

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

Jetzt wird:

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

Es gibt auch eine alternative - weniger bekannte - Form der String-Interpolation mit [email protected] (die Reihenfolge der beiden Symbole ist wichtig). Damit können die Funktionen eines @""-Strings mit $"" gemischt werden, um String-Interpolationen zu unterstützen, ohne dass \\ in Ihrem String benötigt wird. Also die folgenden zwei Zeilen:

var someDir = "a";
Console.WriteLine([email protected]"c:\{someDir}\b\c");

wird ausgeben:

c:\a\b\c
363
David Arno

Es erstellt eine interpolierte Zeichenfolge .

Von MSDN

Wird zum Erstellen von Strings verwendet. Ein interpolierter Zeichenfolgenausdruck sieht folgendermaßen aus: wie eine Vorlagenzeichenfolge, die Ausdrücke enthält. Ein interpolierter Zeichenfolgenausdruck erstellt eine Zeichenfolge durch Ersetzen der enthaltenen Ausdrücke mit den ToString-Darstellungen der Ausdrücke “ Ergebnisse.

ex :

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

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

Sie können Ausdrücke innerhalb der interpolierten Zeichenfolge verwenden

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

Das Schöne daran ist, dass Sie sich nicht wie bei String.Format um die Reihenfolge der Parameter kümmern müssen.

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

Wenn Sie einige Parameter entfernen möchten, müssen Sie alle Zählungen aktualisieren, was nicht mehr der Fall ist.

Beachten Sie, dass der gute alte string.format noch relevant ist, wenn Sie kulturelle Informationen in Ihrer Formatierung angeben möchten.

36
Sleiman Jneidi

Es ist Interpolated Strings. Sie können eine interpolierte Zeichenfolge überall verwenden, wo Sie ein Zeichenfolgenliteral verwenden können. Wenn Ihr Programm den Code mit dem interpolierten String-Literal ausführen würde, berechnet der Code ein neues String-Literal, indem er die Interpolationsausdrücke auswertet. Diese Berechnung findet jedes Mal statt, wenn der Code mit der interpolierten Zeichenfolge ausgeführt wird.

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

In diesem Beispiel wird ein Zeichenfolgenwert erzeugt, bei dem alle Werte der Zeichenfolgeninterpolation berechnet wurden. Es ist das Endergebnis und hat den Typ string. Alle Vorkommen von doppelt geschweiften Klammern (“{{“ and “}}”) werden in eine einzelne geschweifte Klammer umgewandelt.

Ob,

string text = "One";

Dann enthält message "Sample, One".

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

Beispiel

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}");

Ausgabe

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

Referenz - MSDN

16

Coole Funktion. Ich möchte nur betonen, warum dies besser ist als string.format, wenn es für manche Leute nicht offensichtlich ist.

Ich las jemanden, der "order string.format" auf "{0} {1} {2}" lautete, um die Parameter abzugleichen. Sie müssen "{0} {1} {2}" nicht im String-Format bestellen. Sie können auch "{2} {0} {1}" ausführen. Wenn Sie jedoch viele Parameter wie 20 haben, möchten Sie die Zeichenfolge wirklich auf "{0} {1} {2} ... {19}" setzen. Wenn es sich um ein durcheinandergebrachtes Durcheinander handelt, wird es Ihnen schwer fallen, Ihre Parameter in eine Reihe zu bringen.

Mit $ können Sie Parameter inline hinzufügen, ohne Ihre Parameter zu zählen. Dadurch ist der Code viel einfacher zu lesen und zu verwalten.

Der Nachteil von $ ist, dass Sie den Parameter in der Zeichenfolge nicht einfach wiederholen können. Sie müssen ihn eingeben. Wenn Sie müde sind, System.Environment.NewLine einzugeben, können Sie string.format ("... {0} ... {0} ... {0}", System.Environment.NewLine) ausführen. aber in $ müssen Sie es wiederholen. Sie können $ "{0}" nicht ausführen und es an string.format übergeben, da $ "{0}" "0" zurückgibt.

Nebenbei habe ich einen Kommentar in einem anderen duplizierten tpoic gelesen. Ich konnte es nicht kommentieren, also hier ist es. Er hat das gesagt

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

erzeugt mehrere String-Objekte. Das stimmt eigentlich nicht. Wenn Sie dies in einer einzelnen Zeile ausführen, wird nur eine Zeichenfolge erstellt und im Zeichenkettencache abgelegt.

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

Alle geben einen String zurück und erstellen nur einen Wert im Cache.

Auf der anderen Seite:

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

Erzeugt 4 verschiedene Werte im Cache, da 4 ";" vorhanden sind.

Daher ist es einfacher, Code wie folgt zu schreiben, aber Sie würden fünf interpolierte Zeichenfolgen erstellen, wenn Carlos Muñoz korrigiert hat:

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

Dadurch wird eine einzige Zeichenfolge im Cache erstellt, während Sie sehr einfach Code lesen können. Ich bin nicht sicher, was die Leistung angeht, aber ich bin sicher, dass MS sie optimieren wird, wenn sie es nicht bereits tut.

10
BoBoDev

Beachten Sie, dass Sie die beiden auch kombinieren können, was ziemlich cool ist (obwohl es etwas seltsam aussieht):

// simple interpolated verbatim string
WriteLine([email protected]"Path ""C:\Windows\{file}"" not found.");
7
marsze

Es ist bequemer als string.Format und Sie können Intellisense auch hier verwenden.

 enter image description here

Und hier ist meine Testmethode:

[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);
}
6
GorkemHalulu

$ Syntax ist Nizza, aber mit einem Nachteil.

Wenn Sie so etwas wie eine Stringvorlage benötigen, wird dies auf Klassenebene als Feld deklariert ... an einer Stelle, wie es sein sollte.

Dann müssen Sie die Variablen auf derselben Ebene deklarieren ... was nicht wirklich cool ist.

Es ist viel schöner, die String.Format-Syntax für diese Art von Dingen zu verwenden

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);
 }
}

Die Verwendung von Globalen ist nicht wirklich in Ordnung und abgesehen davon funktioniert sie auch nicht mit Globalen 

 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;
 }
}
5
Tom

Das folgende Beispiel zeigt verschiedene Vorteile der Verwendung interpolierter Strings gegenüber string.Format() in Bezug auf Sauberkeit und Lesbarkeit. Es zeigt auch, dass Code in {} wie jedes andere Funktionsargument ausgewertet wird, genauso wie wenn string.Format() aufgerufen würde.

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.
5
Pažout

Ich weiß nicht, wie es funktioniert, aber Sie können es auch verwenden, um Ihre Werte zu tabulieren!

Beispiel:

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

Natürlich können Sie "dies!" Ersetzen. mit einer beliebigen Variable oder irgendetwas Sinnvollem, ebenso wie Sie die Registerkarte ändern können.

5
Een Amok

Es bedeutet die Interpolation von Strings.

Es schützt Sie, da es bei der String-Auswertung einen Schutz für die Kompilierungszeit bietet.

Sie erhalten mit string.Format("{0}{1}",secondParamIsMissing) keine Ausnahme mehr

5
silver

das $ -Zeichen in der Zeichenfolge dient zur Definition der Interpolationszeichenfolge, die ein Feature in C # ist, um die Zeichenfolge zu interpolieren. Die Zeichenfolge ist eine "wahre Zeichenfolge", die interpolierte Ausdrücke enthalten kann

für weitere Informationen ist dies die Quelle der Antwort und des Beispiels: https://docs.Microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated

Hoffe, es hilft Ab 2018

0
Tom Bradley