В C#, я должен использовать string.Пусто или строка.Пустые или "в" в intitialize строку?

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

глядя на закулисный код, вы действительно не видите никакой разницы. Единственная разница в 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#.