¿Cuál es la diferencia entre String.Empty y "" (cadena vacía)?

En .NET, ¿cuál es la diferencia entre String.Emptyy "", y son intercambiables, o hay alguna referencia subyacente o problemas de localización en torno a la igualdad que String.Emptygaranticen que no sea un problema?

En .NET anterior a la versión 2.0, ""crea un objeto mientras string.Emptyno crea ningún objeto ^ref , lo que hacestring.Empty más eficiente.

En la versión 2.0 y posterior de .NET, todas las apariciones se ""refieren al mismo literal de cadena, lo que significa que ""es equivalente a .Empty, pero aún no tan rápido como .Length == 0.

.Length == 0 es la opción más rápida, pero .Empty hace que el código sea un poco más limpio.

Consulte la especificación .NET para obtener más información .

¿Cuál es la diferencia entre String.Empty y "", y son intercambiables?

string.Emptyes un campo de solo lectura, mientras que ""es una constante de tiempo de compilación. Los lugares donde se comportan de manera diferente son:

Valor de parámetro predeterminado en C # 4.0 o superior

void SomeMethod(int ID, string value = string.Empty)
// Error: Default parameter value for 'value' must be a compile-time constant
{
    //... implementation
}

Expresión de caso en la declaración de cambio

string str = "";
switch(str)
{
    case string.Empty: // Error: A constant value is expected. 
        break;

    case "":
        break;

}

Argumentos de atributo

[Example(String.Empty)]
// Error: An attribute argument must be a constant expression, typeof expression 
//        or array creation expression of an attribute parameter type

Las respuestas anteriores eran correctas para .NET 1.1 (mire la fecha de la publicación que vincularon: 2003). A partir de .NET 2.0 y versiones posteriores, esencialmente no hay diferencia. El JIT terminará haciendo referencia al mismo objeto en el montón de todos modos.

De acuerdo con la especificación C #, sección 2.4.4.5: http://msdn.microsoft.com/en-us/library/aa691090(VS.71).aspx

Cada cadena literal no necesariamente da como resultado una nueva instancia de cadena. Cuando dos o más literales de cadena que son equivalentes según el operador de igualdad de cadena (Sección 7.9.7) aparecen en el mismo ensamblaje, estos literales de cadena se refieren a la misma instancia de cadena.

Alguien incluso menciona esto en los comentarios de la publicación de Brad Abram

En resumen, el resultado práctico de "" vs. String.Empty es nulo. El JIT lo resolverá al final.

Personalmente, he descubierto que el JIT es mucho más inteligente que yo, por lo que trato de no ser demasiado inteligente con optimizaciones de microcompiladores como esa. El JIT se desplegará para bucles (), eliminará código redundante, métodos en línea, etc. mejor y en momentos más apropiados de lo que yo o el compilador de C # podríamos anticipar de antemano. Deje que el JIT haga su trabajo :)

String.Emptyes un campo de solo lectura mientras que ""es una constante . Esto significa que no se puede usar String.Emptyen una declaración de cambio porque no es una constante.

Otra diferencia es que String.Empty genera un código CIL más grande. Si bien el código para hacer referencia a "" y String.Empty tiene la misma longitud, el compilador no optimiza la concatenación de cadenas (consulte la publicación del blog de Eric Lippert ) para ver los argumentos de String.Empty. Las siguientes funciones equivalentes

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

generar esta 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 
}

Las respuestas anteriores son técnicamente correctas, pero lo que realmente desea usar, para una mejor legibilidad del código y la menor posibilidad de una excepción es String.IsNullOrEmpty (s)

Tiendo a usarlo en String.Emptylugar de hacerlo ""por una razón simple, pero no obvia: ""y ""NO son lo mismo, el primero tiene 16 caracteres de ancho cero. Obviamente, ningún desarrollador competente va a poner caracteres de ancho cero en su código, pero si llegan allí, puede ser una pesadilla de mantenimiento.

Notas:

• Solía U + FEFF en este ejemplo.

• No estoy seguro de si SO va a comer esos caracteres, pero pruébelo usted mismo con uno de los muchos caracteres de ancho cero

• Solo encontré esto gracias a https://codegolf.stackexchange.com/

Usar en String.Emptylugar de "".

Esto es más por la velocidad que por el uso de la memoria, pero es un consejo útil. El ""es un literal, por lo que actuará como un literal: en el primer uso se crea y para los siguientes usos se devuelve su referencia. ¡Solo ""se almacenará una instancia en la memoria, sin importar cuántas veces la usemos! No veo ninguna penalización de memoria aquí. El problema es que cada vez que ""se usa, se ejecuta un ciclo de comparación para verificar si ""ya está en el grupo interno. Por otro lado, String.Empty hay una referencia a una zona de memoria"" almacenada en .NET Framework . String.Emptyapunta a la misma dirección de memoria para aplicaciones VB.NET y C #. Entonces, ¿por qué buscar una referencia cada vez que la necesita ?"" cuando tiene esa referencia enString.Empty

Referencia: String.Emptyvs""

String.Empty no crea un objeto mientras que "" sí lo hace. Sin embargo, la diferencia, como se señala aquí , es trivial.

Todas las instancias de "" son el mismo literal de cadena interno (o deberían serlo). Por lo tanto, realmente no lanzará un nuevo objeto en el montón cada vez que use "", sino que simplemente cree una referencia al mismo objeto interno. Dicho esto, prefiero la cadena. Vacío. Creo que hace que el código sea más legible.

¡Simplemente no importa!

Alguna discusión pasada de esto:

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 empuja una nueva referencia de objeto a un literal de cadena almacenado en los metadatos.

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

ldsfld empuja el valor de un campo estático en la pila de evaluación

Tiendo a usar en String.Emptylugar de ""porque en mi humilde opinión es más claro y menos VB-ish.

_{Eric Lippert escribió (17 de junio de 2013):
"El primer algoritmo en el que trabajé en el compilador de C # fue el optimizador que maneja las concatenaciones de cadenas. Desafortunadamente no logré portar estas optimizaciones al código base de Roslyn antes de irme; espero que alguien lo haga; llegar a eso! "}

Aquí hay algunos resultados de Roslyn x64 a partir de enero de 2019. A pesar de las observaciones consensuadas de las otras respuestas en esta página, no me parece que el JIT x64 actual esté tratando todos estos casos de manera idéntica, cuando todo está dicho y hecho.

Sin embargo, String.Concattenga en cuenta, en particular, que solo uno de estos ejemplos realmente termina llamando , y supongo que eso es por razones de corrección oscuras (en lugar de una supervisión de optimización). Las otras diferencias parecen más difíciles de explicar.

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

Llegando a esto desde el punto de vista de Entity Framework: EF versiones 6.1.3 parece tratar String.Empty y "" de manera diferente al validar.

string.Empty se trata como un valor nulo para fines de validación y arrojará un error de validación si se usa en un campo Requerido (atribuido); donde como "" pasará la validación y no arrojará el error.

Este problema puede resolverse en EF 7+. Referencia: - https://github.com/aspnet/EntityFramework/issues/2610 ).

Editar: [Obligatorio (AllowEmptyStrings = true)] resolverá este problema, permitiendo que string.Empty se valide.

Como String.Empty no es una constante de tiempo de compilación, no puede usarlo como valor predeterminado en la definición de funciones.

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

Cuando escanea visualmente a través del código, "" aparece coloreado de la misma forma que las cadenas. string.Empty se parece a un acceso regular de miembro de clase. Durante una mirada rápida, es más fácil detectar "" o intuir el significado.

Encuentra las cadenas (la coloración de desbordamiento de pila no está ayudando exactamente, pero en VS esto es más obvio):

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

Todos aquí dieron alguna buena aclaración teórica. Tuve una duda similar. Así que probé una codificación básica. Y encontré una diferencia. Aquí está la diferencia.

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


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

Entonces parece que "Nulo" significa absolutamente vacío y "Cadena. Vacío" significa que contiene algún tipo de valor, pero está vacío.