В C# я должен использовать string.Empty или String.Empty или "" для инициализации строки?
В C# я хочу инициализировать строковое значение пустой строкой.
Как мне это сделать? Каков правильный путь и почему?
string willi = string.Empty;
или же
string willi = String.Empty;
или же
string willi = "";
или что?
31 ответ
Используйте то, что вы и ваша команда считаете наиболее читабельным.
Другие ответы предполагают, что новая строка создается каждый раз, когда вы используете "", Это не так - из-за интернирования строк он будет создаваться либо один раз для сборки, либо один раз для домена приложения (или, возможно, один раз для всего процесса - не уверен на этом фронте). Эта разница незначительна - массово, незначительно.
Однако то, что вы находите более читабельным, - это другое дело. Это субъективно и будет варьироваться от человека к человеку, поэтому я предлагаю вам выяснить, что нравится большинству людей в вашей команде, и все согласны с этим. Лично я нахожу""легче читать.
Аргумент, что""а также" "легко ошибиться друг с другом, на самом деле не моется со мной. Если вы не используете пропорциональный шрифт (а я не работал ни с одним из разработчиков), довольно легко заметить разницу.
На самом деле нет никакой разницы с точки зрения производительности и кода. При тестировании производительности они переходили туда-сюда, между которыми один был быстрее другого, и только на миллисекунды.
Глядя на закулисный код, вы действительно не видите никакой разницы. Единственная разница в IL, который string.Empty используйте код операции ldsfldа также "" использует код операции 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 в String, выбор string.Empty над "" это вопрос выбора одного и придерживаться его. Преимущество использования string.Empty это очень очевидно, что вы имеете в виду, и вы случайно не копируете непечатаемые символы, такие как "\x003" в вашем "",
Я не собирался вмешиваться, но я вижу, что здесь выкидывают какую-то неправильную информацию.
Я лично предпочитаю string.Empty, Это личное предпочтение, и я подчиняюсь воле любой команды, с которой работаю, в каждом конкретном случае.
Как уже упоминали некоторые другие, нет никакой разницы между string.Empty а также String.Empty,
Кроме того, и это малоизвестный факт, использование "" вполне приемлемо. Каждый экземпляр "" в других средах создает объект. Однако.NET интернирует свои строки, поэтому будущие экземпляры будут извлекать ту же неизменяемую строку из внутреннего пула, и любое снижение производительности будет незначительным. Источник: Брэд Абрамс.
Эта тема довольно старая и длинная, поэтому извините, если это поведение упоминалось где-то еще. (И укажите мне на ответ, который охватывает это)
Я нашел разницу в поведении компилятора, если вы используете 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
По сути, если я правильно понимаю, они хотят позволить программисту установить переменную с возвращаемым значением функции для целей отладки, не отвлекая его предупреждающим сообщением, и, таким образом, они ограничивают предупреждение только в случае присваиваний и строк. Пусто это не константа, а поле.
Я лично предпочитаю "", если нет веских причин для чего-то более сложного.
String.Empty а также string.Empty эквивалентны. String имя класса BCL; string это его псевдоним C# (или ярлык, если хотите). То же, что и с Int32 а также int, Смотрите документы для большего количества примеров.
Так далеко как "" обеспокоен, я не совсем уверен.
Лично я всегда использую string.Empty,
Я выполнил этот очень простой тест, используя следующую функцию в консольном приложении:
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. Внутренне они не имеют никакой разницы, и все сводится к удобству того, которое вы хотите использовать в качестве программиста. Такое поведение строкового класса известно как интернирование строк в.Net. У Эрика Липперта есть очень хороший блог, описывающий эту концепцию.
Почти каждый разработчик знает, что означает "". Я лично столкнулся со String.Empty в первый раз, и мне пришлось потратить некоторое время на поиск в Google, чтобы выяснить, действительно ли это одно и то же.
Любой из вышеперечисленных.
Есть много, много лучших вещей для изучения. Например, какого цвета кора лучше всего подходит для дерева, я думаю, что смутно-коричневый с оттенками мха Дульсет.
Никто не упомянул, что в VisualStudio String кодируется цветом иначе, чем строка. Что важно для читабельности. Кроме того, строчные буквы обычно используются для переменных и типов, что не имеет большого значения, но String.Empty - это константа, а не переменная или тип.
string является синонимом для System.String типа, они идентичны.
Значения также идентичны: string.Empty == String.Empty == ""
Я бы не использовал символьную константу "" в коде, скорее string.Empty или же String.Empty - легче понять, что имел в виду программист.
Между string а также String Мне нравится нижний регистр string больше только потому, что я работал с Delphi много лет, а стиль Delphi - в нижнем регистре string,
Итак, если бы я был вашим начальником, вы бы написали string.Empty
Я настоятельно предпочитаю String.Empty, помимо других причин, чтобы вы знали, что это такое, и что вы не случайно удалили содержимое, но в первую очередь для интернационализации. Если я вижу строку в кавычках, мне всегда приходится задумываться, является ли это новым кодом, и его следует поместить в таблицу строк. Поэтому каждый раз, когда код изменяется / пересматривается, вам нужно искать "что-то в кавычках", и да, вы можете отфильтровывать пустые строки, но я говорю людям, что это хорошая практика - никогда не помещать строки в кавычки, если вы не знаете, что они не будут локализованы.,
Я бы предпочел string.Empty над String.Empty потому что вы можете использовать его без необходимости включать using System; в вашем файле.
Что касается комплектации "" над string.EmptyЭто личное предпочтение и должно решаться вашей командой.
Я не имею никакого значения. Последний самый быстрый, чтобы напечатать хотя:)
Это полностью предпочтение в стиле кода, подход к тому, как.NET обрабатывает строки. Впрочем, вот мои мнения:)
Я всегда использую имена типов BCL при доступе к статическим методам, свойствам и полям: String.Empty или же Int32.TryParse(...) или же Double.Epsilon
Я всегда использую ключевые слова C# при объявлении новых экземпляров: int i = 0; или же string foo = "bar";
Я редко использую необъявленные строковые литералы, так как мне нравится иметь возможность сканировать код, чтобы объединить их в повторно используемые именованные константы. В любом случае компилятор заменяет константы на литералы, так что это скорее способ избежать магических строк / чисел и придать им немного больше значения с помощью имени. Плюс изменить значения проще.
Любой из первых двух будет приемлем для меня. Я бы избежал последнего, потому что это довольно легко ввести ошибку, поместив пробел между кавычками. Эту конкретную ошибку было бы трудно обнаружить наблюдением. При условии отсутствия опечаток, все семантически эквивалентны.
[РЕДАКТИРОВАТЬ]
Кроме того, вы можете всегда использовать string или же String для последовательности, но это только я.
Это не имеет значения - это одно и то же. Однако главное, чтобы вы были последовательны
PS Я все время борюсь с этим "что правильно".
Я лично был свидетелем "", приводящего к (незначительным) проблемам дважды. Однажды это произошло из-за ошибки начинающего разработчика, плохо знакомого с командным программированием, а другая была простой опечаткой, но факт использовал string.Empty избежал бы обеих проблем.
Да, это в значительной степени суждение, но когда язык дает вам несколько способов сделать что-то, я склоняюсь к тому, который обладает наибольшим контролем над компилятором и самым сильным соблюдением времени компиляции. Это не "". Это все о выражении конкретных намерений.
Если вы введете string.EMpty или Strng.Empty, компилятор сообщит вам, что вы ошиблись. Немедленно. Он просто не скомпилируется. Как разработчик, вы указываете конкретное намерение, которое компилятор (или другой разработчик) не может никоим образом неверно истолковать, а если вы сделаете это неправильно, вы не сможете создать ошибку.
Если вы наберете "", когда имеете в виду "" или наоборот, компилятор с радостью сделает то, что вы сказали. Другой разработчик может или не сможет найти ваши конкретные намерения. Ошибка создана.
Задолго до string.Empty я использовал стандартную библиотеку, которая определяла константу EMPTY_STRING. Мы по-прежнему используем эту константу в операторах case, где string.Empty не допускается.
Когда бы ни было возможно, заставьте компилятор работать на вас и исключите возможность человеческой ошибки, какой бы маленькой она ни была. ИМО, это козыри "читабельности", как цитировали другие.
Специфичность и время компиляции. Это то, что на ужин.
Я использую "", потому что в моем коде он будет ярко окрашен в желтый цвет... по какой-то причине String.Empty полностью окрашен в моей теме кода Visual Studio. И я считаю, что это имеет для меня самое большое значение.
Я просто смотрел какой-то код, и этот вопрос всплыл у меня в голове, который я прочитал некоторое время назад. Это, безусловно, вопрос читабельности.
Рассмотрим следующий код C#...
(customer == null) ? "" : customer.Name
против
(customer == null) ? string.empty : customer.Name
Лично я нахожу последние менее двусмысленными и более легкими для чтения.
Как отмечают другие, фактические различия незначительны.
Хотя разница очень, ОЧЕНЬ мала, разница все же существует.
1) "" создает объект, а String.Empty - нет. Но этот объект будет создан один раз и на него будут ссылаться из пула строк позже, если у вас есть еще один символ "" в коде.
2) Строка и строка одинаковы, но я бы порекомендовал использовать String.Empty (а также String.Format, String.Copy и т. Д.), Так как точечная нотация указывает на класс, а не на оператора, а класс, начинающийся с заглавной буквы, соответствует C# стандарты кодирования.
Я использую третий, но из двух других первый кажется менее странным. Строка является псевдонимом для String, но, видя их через задание, чувствует себя плохо.
Компилятор должен сделать их одинаковыми в долгосрочной перспективе. Выберите стандарт, чтобы ваш код было легко читать, и придерживайтесь его.
Я думаю, что второе "правильно", но, честно говоря, я не думаю, что это будет иметь значение. Компилятор должен быть достаточно умен, чтобы скомпилировать любой из них в один и тот же байт-код. Я использую "" сам.
На 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... мой уровень ухода низкий;-)
Пустая строка похожа на пустой набор, просто имя, которое все используют для вызова "", Также в формальных языках строки, созданные из алфавита с нулевой длиной, называются пустой строкой. И set, и string имеют специальный символ для этого. Пустая строка: ε и пустое множество: ∅. Если вы хотите поговорить об этой строке нулевой длины, вы назовете ее пустой строкой, чтобы все точно знали, на что вы ссылаетесь. Теперь, если вы называете это пустой строкой, почему бы не использовать string.Empty в коде это показывает намерение явно. Недостатком является то, что он не является константой и поэтому не доступен везде, как в атрибутах. (Это не константа по некоторым техническим причинам, см. Справочный источник.)
Возможно, это спорный комментарий, но в целом я считаю, что моя жизнь легче, если я действую последовательно с Microsoft. Мы не можем знать полностью глубоко укоренившихся причин (иногда очень строгих, а иногда, я полагаю, глупых), почему они делают что-то.
Они используют "" в автоматически генерируемых файлах, таких как файл сборки, так что я этим и занимаюсь. Фактически, когда я пытаюсь заменить любой ниже "" на String.Empty, у меня происходит сбой Visual Studio. Вероятно, этому есть логическое объяснение, но с моими ограниченными знаниями, если я просто буду делать то, что делают они, большую часть времени все получается. (Противоположно: я знаю, что в некоторых автоматически сгенерированных файлах также используется String.Empty, что меня опровергает.:))
<Assembly: System.Reflection.AssemblyCulture("")>
<Assembly: System.Reflection.AssemblyDescription("")>
<Assembly: System.Reflection.AssemblyFileVersion("1.0.0.0")>
<Assembly: System.Reflection.AssemblyKeyFile("")>
<Assembly: System.Reflection.AssemblyProduct("")>
<Assembly: System.Reflection.AssemblyTitle("")>