C#: большая часть читаемой конкатенации строк. лучшая практика [дубликат]

Для чего-то вроде этого (которое, как я предполагаю, отправляется в пользовательский интерфейс) я определенно предпочел бы String.Format . Это позволяет легко интернационализировать строку; вы можете использовать grep для вызовов String.Format и заменить их вашим форматом перевода.

string.Format для меня, но на практике я использую то, что подходит для цели, с учетом производительности и удобочитаемости.

Я бы использовал две переменные.

string.Concat (str1, str2);

Если он содержит константу или что-то, что требует форматирования, тогда.

string.Format ("{0} + {1} = {2}", x, y, x + y);

Или для чего-то вроде SQL-запроса

string SqlQuery = "SELECT col1, col2, col3, col4" + 
                  "FROM table t " + 
                  "WHERE col1 = 1";

И построителя строк, когда производительность имеет значение.

String.Format (...) самый медленный.

Для простых конкатенаций, которые не выполняются в цикле, используйте String.Concat (...) или оператор + , которые переводятся в то же самое под капотом , Насколько мне известно. То, что читаемее, очень субъективно.

Использование StringBuilder для простых конкатенаций является излишним и для простых конкатенаций, и, скорее всего, имеет слишком много накладных расходов. Я бы использовал это только в цикле.

Я предпочитаю String.Format для маленьких строк и StringBuilder для больших. Моя основная причина - удобочитаемость. Для меня гораздо удобнее использовать String.Format (или StringBuilder.AppendFormat ()), но я должен признать, что это просто личное предпочтение.

Для генерации действительно большого текста вы можете рассмотреть возможность использования новых (VS2010) предварительно обработанных шаблонов T4 - они действительно хороши.

Кроме того, если вы когда-либо работали с VB.NET, мне нравится техника XML-букв, о которой Кэтлин Доллард говорила в эпизоде ​​152 hanselminutes .

Предпочтительно использовать:

String.Concat для простых конкатенаций, таких как String.Concat ("foo", bar);

String.Format для сложного форматирования, такого как String.Format (" {1} ", url, text);

StringBuilder для массовых конкатенаций, например:

var sb = new StringBuilder();
sb.AppendLine("function fooBar() {");
sp.AppendLine(String.Join(Environment.NewLine, blah));
sp.AppendLine("}");
page.RegisterClientScript(page.GetType(), sb.ToString());

Избегайте "foo" + "bar" (а также if (foo == "bar") . И особенно String.Format ("{ 0} {1} ", foo, bar) и

throw new Exception("This code was" +
    "written by developer with" +
    "13\" monitor");

Это зависит от использования. Когда вы просто хотите объединить две строки, использование a + b намного более читабельно, чем string.Format ("{0} {1}", a, b) . Однако становится все сложнее, я предпочитаю использовать string.Format .Сравните это:

string x = string.Format("-{0}- ({1})", a, b);

против:

string x = "-" + a + "- (" + b + ")";

Я думаю, что в большинстве случаев очень легко определить наиболее читаемый способ действий. В тех случаях, когда остается спорным, какой из них более читабелен, просто выберите один, потому что ваш босс не платит за эти бессмысленные обсуждения; -)

• string.Format

  для нескольких конкатенаций. для большего я использую

• подход StringBuilder

, даже если производительность не важна. есть командное соглашение, которому я должен следовать

Мое личное предпочтение таково:

Я считаю подход + наиболее удобным для чтения и использую Format() или StringBuilder только если на то есть веские причины (i18n, производительность и т.д.). Я (почти) никогда не использую Concat.

Мне кажется, что подход + легче читать, чем Format(), просто потому, что мне не нужно переходить к концу, чтобы увидеть, какие переменные помещены в {}. А если держатели расположены не в числовом порядке, то читать становится еще труднее.

Но я думаю, что для больших проектов имеет смысл просто принудительно использовать Format в соответствии с руководством по стилю на случай, если код может быть (повторно) использован в проекте, требующем i18n позже.