Я собирался использовать строку verbatim, но я ошибочно набрал $ вместо @.
Но компилятор не дал мне никаких ошибок и скомпилирован успешно.
Я хочу знать, что это такое и что он делает. Я искал его, но ничего не нашел.
Однако это не похоже на стенографическую строку, потому что я не могу написать:
string str = $"text\";
Кто-нибудь знает, что $ перед тем, как строка будет стоять на С#.
string str = $"text";
Я использую Visual Studio 2015 CTP.
$ является короткой для String.Format и используется со строковыми интерполяциями, что является новой особенностью С# 6. Как используется в вашем случае, он ничего не делает, так же как string.Format() ничего не делает.
Он приходит в себя, когда используется для создания строк со ссылкой на другие значения. Что ранее должно было быть написано как:
var anInt = 1;
var aBool = true;
var aString = "3";
var formated = string.Format("{0},{1},{2}", anInt, aBool, aString);
Теперь становится:
var anInt = 1;
var aBool = true;
var aString = "3";
var formated = $"{anInt},{aBool},{aString}";
Также существует альтернатива - менее известная форма строковой интерполяции с использованием [email protected] (порядок двух символов важен). Он позволяет смешивать функции строки @"" с $"" для поддержки интерполяций строк без необходимости \\ в вашей строке. Итак, следующие две строки:
var someDir = "a";
Console.WriteLine([email protected]"c:\{someDir}\b\c");
выведет:
c:\a\b\c
Создает интерполированную строку.
Из MSDN
Используется для построения строк. Интерполированное строковое выражение выглядит как шаблонная строка, содержащая выражения. Интерполированное строковое выражение создает строку, заменяя содержащиеся выражения на представления ToString результатов выражений.
пример:
var name = "Sam";
var msg = $"hello, {name}";
Console.WriteLine(msg); // hello, Sam
Вы можете использовать выражения в интерполированной строке
var msg = $"hello, {name.ToLower()}";
Console.WriteLine(msg); // hello, sam
Приятно то, что вам не нужно беспокоиться о порядке параметров, как в String.Format.
var s = String.Format("{0},{1},{2}...{88}",p0,p1,..,p88);
Теперь, если вы хотите удалить некоторые параметры, вам нужно перейти и обновить все значения, что уже не так.
Обратите внимание, что старый добрый string.format по-прежнему актуален, если вы хотите указать культурную информацию в своем форматировании.
Это Интерполированные строки. Вы можете использовать интерполированную строку везде, где вы можете использовать строковый литерал. При запуске вашей программы будет выполняться код с интерполированным строковым литералом, код вычисляет новый строковый литерал, оценивая выражения интерполяции. Это вычисление происходит каждый раз, когда выполняется код с интерполированной строкой.
var message = $"Sample, {text}";
В этом примере создается строковое значение, в котором были вычислены все значения интерполяции строк. Это конечный результат и имеет строку типа. Все вхождения двойных фигурных скобок ("{{" and "}}") преобразуются в одну фигурную фигуру.
Если
string text = "One";
Затем message содержит "Sample, One".
Console.WriteLine(message); // Sample, One
Пример
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}");
Выход
Full name - Albert Einstein
Full name - Albert Einstein
Full name - Albert Einstein
Ссылка - MSDN
Классная особенность. Я просто хочу подчеркнуть, почему это лучше, чем string.format, если это не очевидно для некоторых людей.
Я прочитал кого-то, говорящего заказывать string.format в "{0} {1} {2}", чтобы соответствовать параметрам. Вы не обязаны заказывать "{0} {1} {2}" в string.format, вы также можете выполнить "{2} {0} {1}". Однако, если у вас много параметров, например, 20, вы действительно хотите упорядочить строку как "{0} {1} {2}... {19}". Если это случайный беспорядок, вам будет трудно выстроить свои параметры.
С помощью $ вы можете добавить параметр в строку без подсчета ваших параметров. Это делает код намного проще для чтения и обслуживания.
Недостатком $ является то, что вы не можете легко повторить параметр в строке, вы должны ввести его. Например, если вы устали набирать System.Environment.NewLine, вы можете выполнить string.format("... {0}... {0}... {0}", System.Environment.NewLine), но в $ вы должны повторить это. Вы не можете сделать $ "{0}" и передать его в string.format, потому что $ "{0}" возвращает "0".
На примечании стороны я прочитал комментарий в другом дублированном tpoic. Я не мог комментировать, так что вот оно. Он сказал, что
string msg = n + " sheep, " + m + " chickens";
создает более одного строкового объекта. Это не правда на самом деле. Если вы делаете это в одной строке, он создает только одну строку и помещается в кеш строк.
1) string + string + string + string;
2) string.format()
3) stringBuilder.ToString()
4) $""
Все они возвращают строку и создают только одно значение в кеше.
С другой стороны:
string+= string2;
string+= string2;
string+= string2;
string+= string2;
Создает 4 разных значения в кеше, потому что есть 4 ";".
Таким образом, будет проще написать код, подобный следующему, но вы бы создали пять интерполированных строк, как исправил Карлос Муньос:
string msg = $"Hello this is {myName}, " +
$"My phone number {myPhone}, " +
$"My email {myEmail}, " +
$"My address {myAddress}, and " +
$"My preference {myPreference}.";
Это создает одну единственную строку в кеше, в то время как у вас очень легко читаемый код. Я не уверен в производительности, но я уверен, что MS оптимизирует это, если еще не делает это.
Обратите внимание, что вы также можете комбинировать два, что довольно круто (хотя выглядит немного странно):
// simple interpolated verbatim string
WriteLine([email protected]"Path ""C:\Windows\{file}"" not found.");
Это удобнее, чем string.Format, и вы также можете использовать intellisense здесь.
И вот мой метод испытаний:
[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);
}
Он обозначает интерполяцию строк.
Он защитит вас, потому что он добавляет защиту времени компиляции при оценке строки.
Вы больше не получите исключение с string.Format("{0}{1}",secondParamIsMissing)
Я не знаю, как это работает, но вы также можете использовать его для внесения ваших значений!
Пример:
Console.WriteLine($"I can tab like {"this !", 5}.");
Конечно, вы можете заменить "это!". с любой переменной или чем-либо значимым, так же, как вы также можете изменить вкладку.
В следующем примере демонстрируются различные преимущества использования интерполированных строк над string.Format() в том, что касается чистоты и читабельности. Он также показывает, что код внутри {} оценивается как любой другой аргумент функции, так же, как если string.Format() мы string.Format().
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.
Синтаксис $ хорош, но с одним недостатком.
Если вам нужно что-то вроде строкового шаблона, который объявляется на уровне класса как поле... ну в одном месте, как и должно быть.
Затем вы должны объявить переменные на том же уровне... что не очень круто.
Гораздо приятнее использовать строку. Синтаксис формата для такого рода вещей
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);
}
}
Использование глобалов не очень хорошо и, кроме того, оно не работает и с глобалами.
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;
}
}
знак $ в строке предназначен для определения строки интерполяции, которая является функцией в С#, для интерполяции строки является "истинной строкой", которая может содержать интерполированные выражения
для получения дополнительной информации это источник ответа и пример: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated