В C#, я должен использовать string.Пусто или строка.Пустые или "в" в intitialize строку?
В C# я хочу инициализировать строковое значение с пустой строкой.
как я должен это сделать? Как правильно и почему?
string willi = string.Empty;
или
string willi = String.Empty;
или
string willi = "";
или что?
29 ответов
используйте все, что вы и ваша команда найдете наиболее читаемым.
другие ответы предложили, что новая строка создается каждый раз, когда вы используете ""
. Это неверно-из - за интернирования строк он будет создан либо один раз на сборку, либо один раз на AppDomain (или, возможно, один раз для всего процесса-не уверен на этом фронте). Эта разница незначительна-массово,массово незначительным.
который вы находите более читаемым другое дело, однако. Это субъективно и будет варьироваться от человека к человеку - поэтому я предлагаю вам выяснить, что нравится большинству людей в вашей команде, и все идут с этим для последовательности. Лично я нахожу ""
легче читать.
аргумент о том, что ""
и " "
легко ошибаются друг для друга, на самом деле не моются со мной. Если вы не используете пропорциональный шрифт (и я не работал с любой разработчики, которые делают) это довольно легко сказать разница.
на самом деле нет никакой разницы с точки зрения производительности и кода. В тестировании производительности они ходили взад и вперед, между которыми один был быстрее против другого, и только на миллисекунды.
глядя на закулисный код, вы действительно не видите никакой разницы. Единственная разница в 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
начните с краткости. Увеличьте другие размеры в соответствии с требованиями тестирования.
следовательно, меньше кода-лучший код: Prefer ""
до 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
над ""
- это вопрос выбора один и придерживаться его. Преимущество использования string.Empty
очень очевидно, что вы имеете в виду, и вы случайно не копируете непечатаемые символы, такие как "\x003"
в своем ""
.
Я не собирался вмешиваться, но я вижу, что здесь выбрасывается неправильная информация.
Я, лично, предпочитаю string.Empty
. Это мое личное предпочтение, и я подчиняюсь воле любой команды, с которой работаю, в каждом конкретном случае.
как упоминали некоторые другие, нет никакой разницы между string.Empty
и String.Empty
.
кроме того, и это малоизвестный факт, использование "" вполне приемлемо. Каждый случай "" воли, в другом среды, создайте объект. Однако .NET Интерны свои строки, поэтому будущие экземпляры будут тянуть ту же неизменяемую строку из пула интернов, и любое попадание производительности будет незначительным. Источник:Брэд Абрамс.
String.Empty
и string.Empty
эквивалентны. String
- это имя класса BCL;string
- это псевдоним C# (или ярлык, если хотите). То же, что и с Int32
и int
. См.документы для получения дополнительных примеров.
насколько ""
обеспокоен, я не совсем уверен.
лично я всегда использую string.Empty
.
почти каждый разработчик там будет знать, что означает"". Я лично столкнулся с String.Пустой в первый раз и пришлось потратить некоторое время на поиск google, чтобы выяснить, действительно ли они are то же самое.
эта тема довольно старая и давно, так что извините если это уже упоминалось где-то еще. (И укажите мне на ответ, который охватывает это)
Я нашел разницу в поведении компилятора, если вы используете 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
В принципе, если я правильно понял, они хотят позволить программисту установить переменную с возвращаемым значением функции для отладка цели без беспокоить его с предупреждающим сообщением и таким образом они ограничили предупреждение только в случае назначения costant и строки.Пустота - это не константа, а поле.
Я выполнил этот очень простой тест, используя следующую функцию в консольном приложении:
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. Поэтому внутренне они не имеют никакой разницы, и все сводится к удобству, которое вы хотите использовать как программист. Это поведение класса string известно как интернировании строк in .Сеть. У Эрика Липперта очень хороший блог здесь С описанием этой концепции.
любой из вышеперечисленных.
есть много, много лучших вещей, чтобы понтифицировать. Например, какого цвета кора больше всего подходит дереву, я думаю, смутно коричневого с оттенками сладкого мха.
Я сильно предпочитаю строку.Пустой, помимо других причин, чтобы убедиться, что вы знаете, что это такое, и что вы случайно не удалили содержимое, но прежде всего для интернационализации. Если я вижу строку в кавычках, мне всегда приходится задаваться вопросом, является ли это новым кодом, и его следует поместить в таблицу строк. Поэтому каждый раз код менять/пересматривать нужно искать "что-то в кавычках" и да, вы можете отфильтровать пустые строки, но я говорю людям, что это хорошая практика, чтобы никогда не поместите строки в кавычки, если вы не знаете, что он не будет локализован.
никто не упомянул, что в VisualStudio строка имеет цветовую кодировку по-разному, чем строка. Что важно для удобочитаемости. Кроме того, нижний регистр обычно используется для vars и типа, не большое дело, но строка.Пусто-это константа, а не var или тип.
string
- это синоним System.String
type, они идентичны.
значения также идентичны: string.Empty == String.Empty == ""
Я бы не использовал символьную константу "" в коде, а string.Empty
или String.Empty
- легче понять, что имел в виду программист.
между string
и String
мне нравится нижний регистр string
больше только потому, что я работал с Delphi в течение многих лет, и стиль Delphi строчный string
.
Итак, если бы я был вашим боссом, Вы были бы пишу string.Empty
Это не имеет значения - они точно то же самое. Однако, главное, что вы должно быть согласовано
p.s. Я все время борюсь с этим "что правильно".
Я использую третий, но из двух первых кажется менее странным. string-это псевдоним для String, но видеть их в задании кажется странным.
любой из первых двух был бы приемлемым для меня. Я бы избегал последнего, потому что относительно легко ввести ошибку, поставив пробел между кавычками. Этот конкретный жучок будет трудно обнаружить путем наблюдения. Не допуская опечаток, все они семантически эквивалентны.
[EDIT]
кроме того, вы можете всегда использовать string
или String
для согласованности, но это только я.
это полностью предпочтение стиля кода, как .NET обрабатывает строки. Однако, вот мое мнение :)
Я всегда использую имена типов BCL при доступе к статическим методам, свойствам и полям:String.Empty
или Int32.TryParse(...)
или Double.Epsilon
Я всегда использую ключевые слова C# при объявлении нового экземпляра: int i = 0;
или string foo = "bar";
Я редко использую необъявленные строковые литералы, поскольку мне нравится сканировать код, чтобы объединить их в многоразовые именованные константы. Этот компилятор все равно заменяет константы литералами, поэтому это больше способ избежать магических строк/чисел и дать им немного больше смысла с именем. Плюс изменение значений проще.
Я лично был свидетелем"", в результате чего (незначительные) проблемы дважды. Один раз из-за ошибки младшего разработчика, Новичка в командном программировании, а другой был простой опечаткой, но факт использования string.Пустой бы избежал обеих проблем.
Да, это очень большой вызов суждения, но когда язык дает вам несколько способов сделать что-то, я склоняюсь к тому, который имеет самый надзор компилятора и самое сильное принудительное исполнение во время компиляции. То есть не "". Все дело в выражении конкретного намерения.
Если ввести строку.Пустой или сильной.Пустой, компилятор дает вам знать, что вы сделали это неправильно. Немедленно. Он просто не будет компилироваться. Как разработчик вы цитируете конкретные намерение, что компилятор (или другой разработчик) не может каким-либо образом неправильно интерпретировать, и когда вы делаете это неправильно, вы не можете создать ошибку.
Если вы вводите "когда вы имеете в виду" или наоборот, компилятор счастливо делает то, что вы велел это сделать. Другой разработчик может или не может быть в состоянии узнать ваше конкретное намерение. Ошибка создана.
задолго до строки.Пустой была вещь, которую я использовал стандартную библиотеку, которая определила константу EMPTY_STRING. Мы все еще используем эту константу в операторах case, где string.Пустой не допускается.
когда это возможно, поставьте компилятор работать на вас, и устранить возможность человеческой ошибки, независимо от того, как мало. IMO, это превосходит "читаемость", как и другие цитируется.
специфичность и соблюдение времени компиляции. Это то, что на ужин.
Я бы пользу string.Empty
над String.Empty
потому что вы можете использовать его без необходимости не включать using System;
в свой файл.
в комплектации ""
над string.Empty
, Это личное предпочтение и должно быть решено вашей командой.
компилятор должен сделать их все же в долгосрочной перспективе. Выберите стандарт, чтобы ваш код был легко читаемым, и придерживайтесь его.
Я просто смотрел на какой-то код, и этот вопрос всплыл в моем уме, который я прочитал некоторое время назад. Это, безусловно, вопрос читаемости.
рассмотрим следующий код на C#...
(customer == null) ? "" : customer.Name
vs
(customer == null) ? string.empty : customer.Name
Я лично нахожу последнее менее двусмысленным и более легким для чтения.
как указывали другие, фактические различия незначительны.
Я использую "", потому что он будет окрашен в желтый цвет в моем коде... по какой-то причине строка.Пустой-все белое в моей теме кода Visual Studio. И я верю, что для меня это самое важное.
Я думаю, что второй "правильный", но, честно говоря, я не думаю, что это будет иметь значение. Компилятор должен быть достаточно умен, чтобы скомпилировать любой из них в тот же байт-код. Я использую "себя".
On 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
в коде, это показывает, что намерение явно. Недостатком является то, что он не является константой и поэтому доступен не везде, как в атрибутах. (Это не константа по некоторым техническим причинам, см. справочный источник.)
в то время как разница очень, очень мало, разница все еще существует.
1) "" создает объект во время строки.Пустым не бывает. Но этот объект будет создан один раз и будет ссылаться из пула строк позже, если у вас есть другой "" в коде.
2) строка и строка одинаковы, но я бы рекомендовал использовать строку.Пустой (а также строка.строка формата.Скопировать и т. д.) поскольку точечная нотация указывает класс, а не оператор, и класс, начинающийся с капитала письмо соответствует стандартам кодирования C#.