В чем разница между String.Empty и (пустой строкой)?

Предыдущие ответы были правильными для .NET 1.1 (посмотрите дату публикации, на которую они ссылаются: 2003). Начиная с .NET 2.0 и новее, разницы практически нет. В любом случае JIT будет ссылаться на один и тот же объект в куче.

Согласно спецификации C #, раздел 2.4.4.5: http://msdn.microsoft.com/en-us/library/aa691090(VS.71).aspx

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

Кто-то даже упоминает об этом в комментариях к посту Брэда Абрама.

Таким образом, практический результат "" vs. String.Empty равен нулю. В конце концов, JIT разберется.

Лично я обнаружил, что JIT намного умнее меня, и поэтому я стараюсь не слишком умничать с подобными оптимизациями микрокомпиляторов. JIT будет разворачивать циклы for (), удалять избыточный код, встроенные методы и т. Д. Лучше и в более подходящее время, чем я или компилятор C # могли когда-либо предвидеть. Пусть JIT сделает свое дело :)

String.Empty - это поле только для чтения, а "" - const. Это означает, что вы не можете использовать String.Empty в операторе switch, потому что он не является константой.

Другое отличие состоит в том, что String.Empty генерирует более крупный код CIL. Хотя код для ссылки на "" и String.Empty имеет одинаковую длину, компилятор не оптимизирует конкатенацию строк (см. сообщение в блоге) для аргументов String.Empty. Следующие эквивалентные функции

string foo()
{
    return "foo" + "";
}
string bar()
{
    return "bar" + string.Empty;
}

генерировать этот IL

.method private hidebysig instance string foo() cil managed
{
    .maxstack 8
    L_0000: ldstr "foo"
    L_0005: ret 
}
.method private hidebysig instance string bar() cil managed
{
    .maxstack 8
    L_0000: ldstr "bar"
    L_0005: ldsfld string [mscorlib]System.String::Empty
    L_000a: call string [mscorlib]System.String::Concat(string, string)
    L_000f: ret 
}

Я предпочитаю использовать String.Empty, а не "" по одной простой, но не очевидной причине: "" и "" НЕ одно и то же, первый фактически содержит 16 символов нулевой ширины. Очевидно, что ни один компетентный разработчик не собирается вставлять символы нулевой ширины в свой код, но если они все же попадут туда, это может стать кошмаром для обслуживания.

Примечания:

• В этом примере я использовал U + FEFF.

• Не уверен, что SO собирается съесть эти символы, но попробуйте сами с одним из множества символов нулевой ширины.

• Я обнаружил это только благодаря https://codegolf.stackexchange.com/

Вышеупомянутые ответы технически верны, но то, что вы действительно можете использовать для лучшей читаемости кода и наименьшей вероятности исключения, - это String.IsNullOrEmpty (s)

Используйте String.Empty вместо "".

Это больше для скорости, чем использования памяти, но это полезный совет. "" - это литерал, поэтому он будет действовать как литерал: при первом использовании он создается, а для следующих применений возвращается его ссылка. В памяти будет храниться только один экземпляр "" независимо от того, сколько раз мы его используем! Я не вижу здесь штрафов за память. Проблема в том, что каждый раз, когда используется "", выполняется цикл сравнения, чтобы проверить, находится ли "" уже в внутреннем пуле. С другой стороны, String.Empty является ссылка на "", хранящийся в зоне памяти .NET Framework. String.Empty указывает на один и тот же адрес памяти для приложений VB.NET и C #. Так зачем искать ссылку каждый раз, когда вам нужно "", когда она есть в String.Empty?

Ссылка: String.Empty vs ""

String.Empty не создает объект, тогда как "" создает. Разница, как указано здесь, тривиальна, тем не мение.

Все экземпляры "" являются одним и тем же интернированным строковым литералом (или должны быть). Таким образом, вы действительно не будете бросать новый объект в кучу каждый раз, когда будете использовать "", а просто создадите ссылку на тот же интернированный объект. Сказав это, я предпочитаю string.Empty. Я думаю, это делает код более читабельным.

Это не имеет значения!

Некоторое прошлое обсуждение этого:

http://www.codinghorror.com/blog/archives/000185.html

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

http://blogs.msdn.com/brada/archive/2003/04/27/50014.aspx

string mystring = "";
ldstr ""

ldstr подталкивает новую ссылку на объект к строковому литералу, хранящемуся в метаданных.

string mystring = String.Empty;
ldsfld string [mscorlib]System.String::Empty

ldsfld помещает значение статического поля в стек оценки

Я предпочитаю использовать String.Empty вместо "", потому что, IMHO, он более понятен и менее VB-иш.

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

Найдите строки (раскраска переполнения стека точно не помогает, но в VS это более очевидно):

var i = 30;
var f = Math.Pi;
var s = "";
var d = 22.2m;
var t = "I am some text";
var e = string.Empty;

_{Эрик Липперт написал (17 июня 2013 г.):
« Первым алгоритмом, над которым я когда-либо работал в компиляторе C #, был оптимизатор, который обрабатывает конкатенации строк. К сожалению, мне не удалось перенести эти оптимизации в кодовую базу Roslyn перед тем, как я ушел; надеюсь, кто-нибудь дойдет до этого! "}

Вот некоторые результаты Roslyn x64 по состоянию на январь 2019 года. Несмотря на согласованные замечания по другим ответам на этой странице, мне не кажется, что текущая JIT x64 обрабатывает все эти случаи одинаково, когда все сказано и сделано.

Однако обратите внимание, в частности, что только один из этих примеров фактически вызывает String.Concat, и я предполагаю, что это из соображений неясной правильности (в отличие от надзора за оптимизацией). Остальные различия объяснить сложнее.

по умолчанию (String) + {default (String), "", String.Empty}

static String s00() => default(String) + default(String);
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    add  rsp,28h
    ret

static String s01() => default(String) + "";
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    add  rsp,28h
    ret

static String s02() => default(String) + String.Empty;
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    mov  rdx,rax
    test rdx,rdx
    jne  _L
    mov  rdx,rax
_L: mov  rax,rdx
    add  rsp,28h
    ret

"" + {по умолчанию (String), "", String.Empty}

static String s03() => "" + default(String);
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    add  rsp,28h
    ret

static String s04() => "" + "";
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    add  rsp,28h
    ret

static String s05() => "" + String.Empty;
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    mov  rdx,rax
    test rdx,rdx
    jne  _L
    mov  rdx,rax
_L: mov  rax,rdx
    add  rsp,28h
    ret

String.Empty + {по умолчанию (String), "", String.Empty}

static String s06() => String.Empty + default(String);
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    mov  rdx,rax
    test rdx,rdx
    jne  _L
    mov  rdx,rax
_L: mov  rax,rdx
    add  rsp,28h
    ret

static String s07() => String.Empty + "";
    mov  rax,[String::Empty]
    mov  rax,qword ptr [rax]
    mov  rdx,rax
    test rdx,rdx
    jne  _L
    mov  rdx,rax
_L: mov  rax,rdx
    add  rsp,28h
    ret

static String s08() => String.Empty + String.Empty;
    mov  rcx,[String::Empty]
    mov  rcx,qword ptr [rcx]
    mov  qword ptr [rsp+20h],rcx
    mov  rcx,qword ptr [rsp+20h]
    mov  rdx,qword ptr [rsp+20h]
    call F330CF60                 ; <-- String.Concat
    nop
    add  rsp,28h
    ret

Microsoft (R) Visual C# Compiler version 2.10.0.0 (b9fb1610)
AMD64 Release
[MethodImpl(MethodImplOptions.NoInlining)]
'SuppressJitOptimization' = false

Исходя из этого с точки зрения Entity Framework: EF версии 6.1.3, похоже, по-разному обрабатывают String.Empty и "" при проверке.

string.Empty обрабатывается как нулевое значение для целей проверки и выдаст ошибку проверки, если оно используется в обязательном (атрибутированном) поле; где "" пройдет проверку и не выдаст ошибку.

Эта проблема может быть решена в EF 7+. Ссылка: - https://github.com/aspnet/EntityFramework/issues/2610 ).

Изменить: [Required (AllowEmptyStrings = true)] решит эту проблему, разрешив проверку string.Empty.

Поскольку String.Empty не является константой времени компиляции, вы не можете использовать ее в качестве значения по умолчанию в определении функции.

public void test(int i=0,string s="")
    {
      // Function Body
    }

Спасибо за очень информативный ответ.

Простите мое незнание, если я ошибаюсь. Я использую VB, но я думаю, что если вы проверите длину неназначенной строки (то есть IS Nothing), она вернет ошибку. Я начал программировать в 1969 году, так что я сильно отставал, однако я всегда тестировал строки, объединяя пустую строку (). Например. (на любом языке): -

if string + "" = ""

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

string str=null;
Console.WriteLine(str.Length);  // Exception(NullRefernceException) for pointing to null reference. 


string str = string.Empty;
Console.WriteLine(str.Length);  // 0

Кажется, что «Null» означает абсолютно пустое значение, а «String.Empty» означает, что он содержит какое-то значение, но он пуст.