另一个区别是字符串。Empty生成更大的CIL代码。而用于引用“”和String的代码。Empty是相同的长度，编译器不会为string优化字符串连接(参见Eric Lippert的博客文章)。空的参数。以下等价函数

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 
}

前面的答案对于。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是nil。JIT最终会弄清楚的。

就我个人而言，我发现JIT比我聪明得多，所以我尽量在微编译器优化方面不太聪明。JIT将展开for()循环，删除冗余代码，内联方法等，在比我或c#编译器之前预期的更好和更合适的时间。让JIT来做它的工作吧:)

Eric Lippert写道(2013年6月17日):“我在c#编译器中工作过的第一个算法是处理字符串连接的优化器。不幸的是，在我离开Roslyn之前，我没有设法将这些优化移植到Roslyn代码库中;希望有人能做到!”

以下是截至2019年1月的一些Roslyn x64结果。尽管本页上的其他答案是一致的，但在我看来，当前的x64 JIT并没有将所有这些情况都一视同仁。

但是要特别注意，这些示例中只有一个最终调用了String。Concat，我猜这是由于模糊的正确性原因(而不是优化疏忽)。其他的差异似乎很难解释。

default（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

“” + { default（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 + { default（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

字符串。Empty是只读字段，而""是const字段。这意味着您不能使用String。在switch语句中为空，因为它不是常量。

使用字符串。空而不是""。

This is more for speed than memory usage but it is a useful tip. The "" is a literal so will act as a literal: on the first use it is created and for the following uses its reference is returned. Only one instance of "" will be stored in memory no matter how many times we use it! I don't see any memory penalties here. The problem is that each time the "" is used, a comparing loop is executed to check if the "" is already in the intern pool. On the other side, String.Empty is a reference to a "" stored in the .NET Framework memory zone. String.Empty is pointing to same memory address for VB.NET and C# applications. So why search for a reference each time you need "" when you have that reference in String.Empty?

参考:字符串。Empty和""

""的所有实例都是相同的，被分隔的字符串字面量(或者它们应该是)。因此，每次使用""时，实际上不会在堆上抛出一个新对象，而只是创建一个对相同的内部对象的引用。话虽如此，我还是更喜欢字符串。我认为这使代码更具可读性。