Apa maksud $ sebelum string?

Saya akan menggunakan string verbatim tetapi saya keliru diketik $bukan @.

Tetapi Compiler tidak memberi saya Kesalahan dan Kompilasi berhasil.

Saya ingin tahu apa itu dan apa fungsinya. Saya mencarinya tetapi saya tidak dapat menemukan apa pun.

Namun tidak seperti string kata demi kata karena saya tidak dapat menulis:

string str = $"text\";

Apakah ada yang tahu apa yang $sebelum string berdiri dalam C #.

string str = $"text";

Saya menggunakan Visual studio 2015 CTP.

$pendek untuk String.Formatdan digunakan dengan interpolasi string, yang merupakan fitur baru dari C # 6. Seperti yang digunakan dalam kasus Anda, itu tidak melakukan apa-apa, sama seperti string.Format()tidak melakukan apa-apa.

Ini menjadi miliknya sendiri ketika digunakan untuk membangun string dengan mengacu pada nilai-nilai lain. Apa yang sebelumnya harus ditulis sebagai:

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

Sekarang menjadi:

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

Ada juga alternatif - kurang terkenal - bentuk interpolasi string menggunakan $@ (urutan kedua simbol itu penting). Ini memungkinkan fitur-fitur @""string untuk dicampurkan dengan $""untuk mendukung interpolasi string tanpa perlu untuk \\seluruh string Anda. Jadi dua baris berikut:

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

akan menampilkan:

c:\a\b\c

Ini menciptakan string yang diinterpolasi .

Dari MSDN

Digunakan untuk membangun string. Ekspresi string terinterpolasi tampak seperti string template yang berisi ekspresi. Ekspresi string terinterpolasi menciptakan string dengan mengganti ekspresi yang terkandung dengan representasi ToString dari hasil ekspresi.

mis:

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

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

Anda dapat menggunakan ekspresi dalam string yang diinterpolasi

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

Yang menyenangkan tentang itu adalah Anda tidak perlu khawatir tentang urutan parameter seperti yang Anda lakukan String.Format.

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

Sekarang jika Anda ingin menghapus beberapa parameter Anda harus pergi dan memperbarui semua penghitungan, yang tidak lagi berlaku.

Perhatikan bahwa barang lama string.formatmasih relevan jika Anda ingin menentukan info budaya dalam pemformatan Anda .

Kode Contoh

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

Keluaran

Full-Name - Albert Einstein
Full-Name - Albert Einstein
Full-Name - Albert Einstein

Ini adalah String Interpolasi . Anda dapat menggunakan string interpolasi di mana saja Anda bisa menggunakan string literal. Saat menjalankan program Anda akan mengeksekusi kode dengan string literal interpolasi, kode menghitung string literal baru dengan mengevaluasi ekspresi interpolasi. Komputasi ini terjadi setiap kali kode dengan string interpolasi dieksekusi.

Contoh berikut menghasilkan nilai string di mana semua nilai interpolasi string telah dihitung. Ini adalah hasil akhir dan memiliki tipe string. Semua kejadian kurung kurawal ganda (“{{“ and “}}”)dikonversi menjadi kurawal kurawal tunggal.

string text = "World";
var message = $"Hello, {text}";

Setelah mengeksekusi di atas 2 baris, variabel messageberisi "Halo, Dunia".

Console.WriteLine(message); // Prints Hello, World

Referensi - MSDN

Fitur keren. Saya hanya ingin menunjukkan penekanan pada mengapa ini lebih baik daripada string.format jika tidak jelas bagi sebagian orang.

Saya membaca seseorang yang mengatakan urutan string.format ke "{0} {1} {2}" untuk mencocokkan parameter. Anda tidak dipaksa untuk memesan "{0} {1} {2}" di string.format, Anda juga dapat melakukan "{2} {0} {1}". Namun, jika Anda memiliki banyak parameter, seperti 20, Anda benar-benar ingin mengurutkan string menjadi "{0} {1} {2} ... {19}". Jika berantakan, Anda akan kesulitan mengatur parameter Anda.

Dengan $, Anda dapat menambahkan parameter sebaris tanpa menghitung parameter Anda. Ini membuat kode lebih mudah dibaca dan dipelihara.

Kelemahan dari $ adalah, Anda tidak dapat mengulangi parameter dalam string dengan mudah, Anda harus mengetiknya. Misalnya, jika Anda bosan mengetik System.Environment.NewLine, Anda dapat melakukan string.format ("... {0} ... {0} ... {0}", System.Environment.NewLine), tetapi, dalam $, Anda harus mengulanginya. Anda tidak dapat melakukan $ "{0}" dan meneruskannya ke string.format karena $ "{0}" mengembalikan "0".

Di samping catatan, saya telah membaca komentar di tpoic duplikat lain. Saya tidak bisa berkomentar, jadi ini dia. Ia mengatakan bahwa

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

membuat lebih dari satu objek string. Ini sebenarnya tidak benar. Jika Anda melakukan ini dalam satu baris, itu hanya membuat satu string dan ditempatkan di cache string.

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

Semuanya mengembalikan string dan hanya membuat satu nilai dalam cache.

Di samping itu:

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

Menciptakan 4 nilai berbeda dalam cache karena ada 4 ";".

Dengan demikian, akan lebih mudah untuk menulis kode seperti berikut ini, tetapi Anda akan membuat lima string yang diinterpolasi saat Carlos Muñoz mengoreksi:

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

Ini menciptakan satu string tunggal dalam cache sementara Anda memiliki kode yang sangat mudah dibaca. Saya tidak yakin tentang kinerjanya, tetapi, saya yakin MS akan mengoptimalkannya jika belum melakukannya.

Perhatikan bahwa Anda juga dapat menggabungkan keduanya, yang cukup keren (meskipun terlihat agak aneh):

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

Ini lebih nyaman daripada string.Format dan Anda bisa menggunakan intellisense di sini juga.

Dan inilah metode pengujian saya:

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

Ini menandakan interpolasi string.

Ini akan melindungi Anda karena itu menambah perlindungan waktu kompilasi pada evaluasi string.

Anda tidak akan lagi mendapatkan pengecualian dengan string.Format("{0}{1}",secondParamIsMissing)

Contoh berikut menyoroti berbagai keuntungan menggunakan string interpolasi string.Format()sejauh kebersihan dan keterbacaan berjalan. Ini juga menunjukkan bahwa kode di dalam {}dievaluasi seperti argumen fungsi lainnya, sama seperti jika string.Format()kita dipanggil.

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.

$ Sintaks bagus, tetapi dengan satu kelemahan.

Jika Anda membutuhkan sesuatu seperti templat string, yang dideklarasikan pada tingkat kelas sebagai bidang ... yah di satu tempat sebagaimana mestinya.

Maka Anda harus mendeklarasikan variabel pada tingkat yang sama ... yang tidak terlalu keren.

Jauh lebih baik menggunakan string. Sintaks untuk hal-hal semacam ini

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

Penggunaan global tidak benar-benar baik dan selain itu - juga tidak bekerja dengan global

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

Saya tidak tahu cara kerjanya, tetapi Anda juga dapat menggunakannya untuk menilai nilai Anda!

Contoh:

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

Tentu saja, Anda dapat mengganti "ini!" dengan variabel apa pun atau apa pun yang bermakna, sama seperti Anda juga dapat mengubah tab.

tanda $ pada string adalah untuk definisi string interpolasi yang merupakan fitur dalam C # untuk menginterpolasi string adalah "string sejati" yang mungkin berisi ekspresi yang diinterpolasi

untuk informasi lebih lanjut, inilah sumber jawaban dan contohnya: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated