.net - que - string.empty c#

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

Question

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

Answer 1

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

string.Empty es 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 instrucción switch

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

Answer 2

¡Simplemente no importa!

Alguna discusión pasada de esto:

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

ref

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

Answer 3

Como String.Empty no es una constante de tiempo de compilación, no se puede usar como un valor predeterminado en la definición de la función.

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

Answer 4

Desde este punto de vista de Entity Framework: las versiones de EF 6.1.3 parecen tratar a 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 "" pasará la validación y no lanzará el error.

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

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

Answer 5

En .NET anterior a la versión 2.0, "" crea un objeto mientras string.Empty no crea ninguna ^ref objeto, lo que hace que string.Empty sea ​​más eficiente.

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

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

Ver la especificación .NET para más información .

Answer 6

Las respuestas anteriores fueron correctas para .NET 1.1 (mire la fecha de la publicación que vincularon: 2003). A partir de .NET 2.0 y 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 de C #, sección 2.4.4.5: http://msdn.microsoft.com/en-us/library/aa691090(VS.71).aspx

Cada literal de cadena no necesariamente resulta en 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 "" contra String.Empty es nulo. El JIT lo resolverá al final.

He encontrado, personalmente, que el JIT es mucho más inteligente que yo, por lo que trato de no ser demasiado inteligente con optimizaciones de micro compiladores como esas. El JIT se desplegará para () bucles, eliminará el código redundante, los 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. Deja que el JIT haga su trabajo :)

Answer 7

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

Answer 8

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 los argumentos de String.Empty. Las siguientes funciones equivalentes

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

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

Answer 9

String.Empty no crea un objeto mientras que "" lo hace. La diferencia, como se señala ref , es trivial, sin embargo.

Answer 10

Todas las instancias de "" son iguales, literal de cadena internada (o deberían ser). Así que realmente no lanzará un nuevo objeto en el montón cada vez que use "", sino que simplemente creará una referencia al mismo objeto interno. Habiendo dicho eso, prefiero string.Empty. Creo que hace que el código sea más legible.

Answer 11

Todo el mundo aquí dio una buena aclaración teórica. Tuve una duda similar. Así que intenté una codificación básica en él. 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

Así que parece que "Null" significa absolutamente nulo y "String.Empty" significa que contiene algún tipo de valor, pero está vacío.

Answer 12

String.Empty a usar String.Empty lugar de "" por una razón simple pero no obvia: "" y "" NO son lo mismo, el primero tiene en realidad 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:

• Utilicé U+FEFF en este ejemplo.

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

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

Answer 13

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

Answer 14

Utilice String.Empty lugar de "" .

Esto es más para la velocidad que 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 una instancia de "" se almacenará 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 utiliza el "" , se ejecuta un ciclo de comparación para comprobar si el "" ya está en el grupo interno. En el otro lado, String.Empty es una referencia a "" almacenada en la zona de memoria de .NET Framework . String.Empty apunta a la misma dirección de memoria para aplicaciones VB.NET y C #. Entonces, ¿por qué buscar una referencia cada vez que necesitas "" cuando tienes esa referencia en String.Empty ?

Referencia: String.Empty vs ""

Answer 15

string mystring = "";
ldstr ""

ldstr una nueva referencia de objeto en una cadena literal almacenada en los metadatos.

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

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

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