В C # следует ли использовать string.Empty или String.Empty или “” для инициализации строки?

В C # я хочу инициализировать строковое значение пустой строкой.

Как мне это сделать? Каков правильный путь и почему?

string willi = string.Empty; 

или

 string willi = String.Empty; 

или

 string willi = ""; 

или что?

Используйте все, что вы и ваша команда найдете наиболее читаемыми.

Другие ответы предполагали, что новая строка создается каждый раз, когда вы используете "" . Это неверно – из-за интернирования строк он будет создан один раз на сборку или один раз для AppDomain (или, возможно, один раз для всего процесса – не уверен на этом фронте). Это различие незначительно – массово, массово незначительно.

Однако то, что вы считаете более читаемым, – это другой вопрос. Это субъективно и будет варьироваться от человека к человеку – поэтому я предлагаю вам узнать, что такое большинство людей в вашей команде, и все это делается для обеспечения последовательности. Лично я считаю, что "" легче читать.

Аргумент, что "" и " " легко ошибаются друг для друга, на самом деле не стирается. Если вы не используете пропорциональный шрифт (и я не работал с разработчиками, которые это делают), довольно легко сказать разницу.

На самом деле нет никакой разницы с точки зрения производительности и кода. При тестировании производительности они шли туда и обратно, между которыми был быстрее, чем другой, и только на миллисекундах.

Смотря на код за кулисами, вы действительно не видите никакой разницы. Единственное различие заключается в IL, в котором string.Empty использует опкод ldsfld а "" использует код opcode ldstr , но это только потому, что string.Empty является статическим, и обе инструкции выполняют одно и то же. Если вы посмотрите на сборку, которая будет создана, она будет точно такой же.

Код C #

 private void Test1() { string test1 = string.Empty; string test11 = test1; } private void Test2() { string test2 = ""; string test22 = test2; } 

Код IL

 .method private hidebysig instance void Test1() cil managed { // Code size 10 (0xa) .maxstack 1 .locals init ([0] string test1, [1] string test11) IL_0000: nop IL_0001: ldsfld string [mscorlib]System.String::Empty IL_0006: stloc.0 IL_0007: ldloc.0 IL_0008: stloc.1 IL_0009: ret } // end of method Form1::Test1 
 .method private hidebysig instance void Test2() cil managed { // Code size 10 (0xa) .maxstack 1 .locals init ([0] string test2, [1] string test22) IL_0000: nop IL_0001: ldstr "" IL_0006: stloc.0 IL_0007: ldloc.0 IL_0008: stloc.1 IL_0009: ret } // end of method Form1::Test2 

Код сборки

  string test1 = string.Empty; 0000003a mov eax,dword ptr ds:[022A102Ch] 0000003f mov dword ptr [ebp-40h],eax string test11 = test1; 00000042 mov eax,dword ptr [ebp-40h] 00000045 mov dword ptr [ebp-44h],eax 
  string test2 = ""; 0000003a mov eax,dword ptr ds:[022A202Ch] 00000040 mov dword ptr [ebp-40h],eax string test22 = test2; 00000043 mov eax,dword ptr [ebp-40h] 00000046 mov dword ptr [ebp-44h],eax 

Лучший код не является кодом вообще :

Фундаментальный характер кодирования заключается в том, что наша задача, как программисты, состоит в том, чтобы признать, что каждое принятое нами решение является компромиссом. […] Начните с краткости. Увеличьте другие размеры, необходимые при тестировании.

Следовательно, меньше кода лучше кода: Предпочитаете "" для string.Empty или String.Empty . Эти два раза в шесть раз дольше без каких-либо дополнительных преимуществ – безусловно, никакой дополнительной ясности, поскольку они выражают ту же самую информацию.

Одно отличие состоит в том, что если вы используете синтаксис switch-case , вы не можете записать case string.Empty: потому что это не константа. Вы получаете Compilation error : A constant value is expected

Посмотрите на эту ссылку для получения дополнительной информации: string-empty-versus-empty-quotes

Я предпочел бы string для String . выбирая string.Empty over "" – это вопрос выбора одного и придерживания его. Преимущество использования string.Empty – это очень очевидно, что вы имеете в виду, и вы случайно не копируете непечатаемые символы, такие как "\x003" в вашем "" .

Я не собирался звонить, но я вижу, что некоторая неправильная информация выбрасывается здесь.

Я лично предпочитаю string.Empty . Это личное предпочтение, и я склоняюсь к воле любой команды, с которой я работаю, в каждом конкретном случае.

Как уже отмечали некоторые другие, между string.Empty и String.Empty нет никакой разницы.

Кроме того, и это малоизвестный факт, использование «» вполне приемлемо. Каждый экземпляр объекта «» в других средах создает объект. Тем не менее, .NET ставит свои строки, поэтому будущие экземпляры будут вытаскивать одну и ту же неизменяемую строку из внутреннего пула, и любое поражение производительности будет незначительным. Источник: Брэд Абрамс .

Я лично предпочитаю “”, если нет веской причины для чего-то более сложного.

String.Empty и string.Empty эквивалентны. String – это имя classа BCL; string – это псевдоним C # (или ярлык, если хотите). То же, что и с Int32 и int . Дополнительную информацию см. В документах .

Что касается "" , я не уверен.

Лично я всегда использую string.Empty .

Почти каждый разработчик знает, что означает «». Я лично столкнулся с String.Empty в первый раз и вынужден был потратить некоторое время на поиски Google, чтобы выяснить, действительно ли они такие же.

Эта тема довольно старая и длинная, поэтому извините меня, если это поведение было упомянуто где-то в другом месте. (И укажите мне ответ, который охватывает это)

Я нашел разницу в поведении компилятора, если вы используете string.Empty или двойные кавычки. Разница проявляется, если вы не используете строковую переменную, инициализированную с помощью string.Empty или с двойными кавычками.

В случае инициализации с помощью string.Empty тогда предупреждение компилятора

 CS0219 - The variable 'x' is assigned but its value is never used 

никогда не выделяется, в то время как в случае инициализации с двойными кавычками вы получаете ожидаемое сообщение.

Это поведение объясняется в статье Connect по этой ссылке: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

В принципе, если я правильно понимаю, они хотят позволить программисту установить переменную с возвращаемым значением функции для целей отладки, не беспокоя его предупреждением, и поэтому они ограничивают это предупреждение только в случае присвоений и строки затрат. Пустое не постоянное, а поле.

Я выполнил этот очень простой тест, используя следующую функцию в консольном приложении:

 private static void CompareStringConstants() { string str1 = ""; string str2 = string.Empty; string str3 = String.Empty; Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True } 

Это наводит на мысль, что все три переменные, а именно str1 , str2 и str3 хотя и инициализируются с использованием другого синтаксиса, но указывают на точно такой же объект (нулевой длины) в памяти. Я выполнил этот тест в консольном приложении .Net 4.5. Таким образом, внутри они не имеют никакой разницы, и все это сводится к удобству, которую вы хотите использовать в качестве программиста. Такое поведение строкового classа известно как интернирование строк в .Net. У Эрика Липперта есть очень хороший блог, описывающий эту концепцию.

Любой из вышеперечисленных.

Есть много, много лучших вещей для понтификата. Например, какая цветная кора лучше всего подходит дереву, я думаю, что расплывчатый коричневый цвет с оттенками мультика.

Я сильно предпочитаю String.Empty, кроме других причин, чтобы вы знали, что это такое, и что вы случайно не удалили содержимое, но прежде всего для интернационализации. Если я вижу строку в кавычках, то мне всегда нужно задаться вопросом, является ли это новым кодом, и его следует поместить в таблицу строк. Поэтому каждый раз, когда код изменяется или просматривается, вам нужно искать «что-то в кавычках», и да, вы можете отфильтровать пустые строки, но я говорю людям, что хорошая практика никогда не ставить строки в кавычки, если вы не знаете, что они не будут локализованы ,

Никто не упоминал, что в VisualStudio String по-разному кодируется цвет, а затем строка. Это важно для читаемости. Кроме того, нижний регистр обычно используется для vars и типа, но не для больших целей, но String.Empty является константой, а не var или type.

Я не понимаю. Последний самый быстрый, чтобы напечатать хотя 🙂

string – синоним типа System.String , они идентичны.

Значения также идентичны: string.Empty == String.Empty == ""

Я бы не использовал символьную константу «” в коде, а скорее string.Empty или String.Empty – легче понять, что означал программист.

Между string и String мне нравится строчная string более просто потому, что я много лет работал с Delphi, а стиль Delphi – строчная string .

Итак, если бы я был вашим боссом, вы бы написали string.Empty

Это не имеет значения – они точно такие же. Однако, главное, что вы должны быть последовательными

ps Я все время борюсь с такими «правильными».

Я использую третий, но из двух других первый кажется менее странным. string – это псевдоним для String, но просмотр их по заданию отключается.

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

[РЕДАКТИРОВАТЬ]

Кроме того, вы можете всегда использовать string или String для согласованности, но это только я.

Это полностью предпочтение в стиле кода, а также то, как .NET обрабатывает строки. Однако, вот мои мнения 🙂

Я всегда использую имена типа BCL при доступе к статическим методам, свойствам и полям: String.Empty или Int32.TryParse(...) или Double.Epsilon

Я всегда использую ключевые слова C # при объявлении новых экземпляров: int i = 0; или string foo = "bar";

Я редко использую необъявленные строковые литералы, так как мне нравится сканировать код, чтобы объединить их в многократно используемые константы. Компилятор в любом случае заменяет константы литералами, поэтому это скорее способ избежать магических строк / чисел и дать им немного больше смысла с именем. Плюс изменение значений проще.

Я лично стал свидетелем “”, что привело к (второстепенным) проблемам дважды. Однажды была из-за ошибки младшего разработчика, нового для командного программирования, а другая была простой опечаткой, но факт заключается в использовании string.Empty избежал бы обеих проблем.

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

Если вы наберете string.EMpty или Strng.Empty, компилятор сообщит вам, что вы сделали это неправильно. Немедленно. Он просто не будет компилироваться. Как разработчик вы ссылаетесь на конкретное намерение, что компилятор (или другой разработчик) никоим образом не может неверно интерпретироваться, и когда вы делаете это неправильно, вы не можете создать ошибку.

Если вы наберете «», когда имеете в виду «» или наоборот, компилятор с радостью сделает то, что вы ему сказали. Другой разработчик может или не сможет понять ваши конкретные намерения. Создан баг.

Задолго до string.Empty было то, что я использовал стандартную библиотеку, которая определяла константу EMPTY_STRING. Мы по-прежнему используем эту константу в операторах case, где string.Empty не допускается.

Когда это возможно, поставьте компилятор для работы на вас и устраните возможность человеческой ошибки, какой бы малой она ни была. ИМО, это превосходит «читаемость», как цитировали другие.

Специфичность и компиляция времени. Это то, что на ужин.

Я бы string.Empty над String.Empty потому что вы можете использовать его без необходимости включать using System; в вашем файле.

Что касается выбора "" над string.Empty , это личное предпочтение и должно решаться вашей командой.

Компилятор должен сделать их одинаковыми в долгосрочной перспективе. Выберите стандарт, чтобы ваш код был легко читаемым и придерживался его.

Я просто смотрел на какой-то код, и этот вопрос всплыл у меня в голове, который я прочитал некоторое время назад. Это, безусловно, вопрос читаемости.

Рассмотрим следующий код C # …

 (customer == null) ? "" : customer.Name 

против

 (customer == null) ? string.empty : customer.Name 

Я лично считаю, что последние менее двусмысленны и легче читать.

Как отмечают другие, фактические различия незначительны.

Я использую “”, потому что он будет окрашен в желтый код ярко-желтого цвета … по какой-то причине String.Empty является белым в моей теме Visual Studio Code. И я считаю, что это для меня самое главное.

Я думаю, что второй – «правильный», но, честно говоря, я не думаю, что это будет иметь значение. Компилятор должен быть достаточно умным, чтобы скомпилировать любой из них в тот же самый байт-код. Я сам использую “”.

На http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

Как предполагает Дэвид, разница между String.Empty и "" довольно мала, но есть разница. "" фактически создает объект, его скорее всего вытащит из пула старта, но все же … пока String.Empty создаст объект … поэтому, если вы действительно ищете в конечном итоге эффективность памяти, я предлагаю String.Empty . Тем не менее, вы должны иметь в виду, что разница настолько велика, что вам больше не понравится в вашем коде …
Что касается System.String.Empty или string.Empty или String.Empty … мой уровень обслуживания низкий 😉

Пустая строка похожа на пустой набор, просто имя, которое каждый использует для вызова "" . Также в формальных языках строки, созданные из алфавита с нулевой длиной, называются пустой строкой. Оба набора и строка имеют для него специальный символ. Пустая строка: ε и пустое множество: ∅. Если вы хотите поговорить об этой строке нулевой длины, вы назовете ее пустой строкой, чтобы все знали точно, о чем вы говорите. Теперь, если вы string.Empty его пустой строкой, почему бы не использовать string.Empty в коде, ее показывает, что намерение явно. Недостатком является то, что он не является постоянным и, следовательно, недоступен везде, как в атрибутах. (Это не является постоянной по некоторым техническим причинам, см. Исходный источник.)

Хотя разница очень, ОЧЕНЬ мало, разница все еще существует.

1) “” создает объект, а String.Empty – нет. Но этот объект будет создан один раз и будет ссылаться на пул строк позже, если у вас есть еще один код в коде.

2) Строка и строка одинаковы, но я бы рекомендовал использовать String.Empty (а также String.Format, String.Copy и т. Д.), Так как точечная обозначение обозначает class, а не оператор, а class, начинающийся с заглавной буквы, соответствует C #.

  • Форматировать строку Go без печати?
  • Java: String split (): Я хочу, чтобы он включал пустые строки в конце
  • Является ли строка Java действительно неизменной?
  • В C, почему я не могу назначить строку массиву символов после ее объявления?
  • Как форматировать строки в Java
  • Строка неизменна. В чем же смысл?
  • Когда использовать StringBuilder в Java
  • искать текстовый файл с помощью c # и отображать номер строки и полную строку, содержащую ключевое слово поиска
  • Не являются ли строки Python неизменяемыми? Тогда почему работает + "" + b?
  • Как написать символ и в файле android strings.xml
  • Разделение строки Java удалено пустым значением
  • Давайте будем гением компьютера.