Pregunta En C #, ¿debería usar string.Empty o String.Empty o "" para inicializar una cadena?


En C #, quiero inicializar un valor de cadena con una cadena vacía.

¿Cómo debería hacer esto? ¿Cuál es el camino correcto y por qué?

string willi = string.Empty;

o

string willi = String.Empty;

o

string willi = "";

¿o que?


617
2017-11-04 19:49


origen


Respuestas:


Usa lo que tú y tu equipo encuentren más legible.

Otras respuestas han sugerido que se cree una nueva cadena cada vez que use "". Esto no es cierto: debido al interrogatorio de cadenas, se creará una vez por conjunto o una vez por dominio de aplicación (o posiblemente una vez para todo el proceso, no estoy seguro en ese frente). Esta diferencia es insignificante: masivamente, macizamente insignificante.

Sin embargo, lo que encuentres más legible es una cuestión diferente. Es subjetivo y variará de una persona a otra, por lo que le sugiero que descubra lo que le gusta a la mayoría de la gente de su equipo, y todo por la coherencia. Personalmente encuentro "" más fácil de leer

El argumento que "" y " " se confunden fácilmente el uno con el otro realmente no se lava conmigo. A menos que esté usando una fuente proporcional (y no he trabajado con alguna desarrolladores que sí lo hacen) es bastante fácil notar la diferencia.


709
2017-11-04 20:07



Realmente no hay diferencia de un punto de vista de rendimiento y código generado. En las pruebas de rendimiento, iban y venían entre los cuales uno era más rápido que el otro, y solo en milisegundos.

Al mirar el código detrás de escena, tampoco ves ninguna diferencia. La única diferencia está en IL, que string.Empty usa el opcode ldsfld y "" usa el código de operación ldstr, pero eso es solo porque string.Empty es estático, y ambas instrucciones hacen lo mismo. Si miras el conjunto que se produce, es exactamente lo mismo.

C # Code

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

Código 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

Código de ensamblaje

        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 

355
2017-10-19 13:31



El mejor código es ningún código en absoluto:

La naturaleza fundamental de la codificación es que nuestra tarea, como programadores, es reconocer que cada decisión que tomamos es una compensación. [...] Comience con brevedad. Aumente las otras dimensiones según lo requiera la prueba.

En consecuencia, menos código es mejor código: Prefiere "" a string.Empty o String.Empty. Esos dos son seis veces más sin ningún beneficio agregado, sin ninguna claridad adicional, ya que expresan exactamente la misma información.


68
2017-11-04 20:04



Una diferencia es que si usa un switch-case sintaxis, no puedes escribir case string.Empty: porque no es una constante Obtienes un Compilation error : A constant value is expected

Mira este enlace para más información: string-empty-versus-empty-quotes


45
2017-08-26 08:58



preferiría string a String. Elegir string.Empty encima "" es una cuestión de elegir uno y aferrarse a él. Ventaja de usar string.Empty es muy obvio a lo que se refiere, y no copia accidentalmente caracteres no imprimibles como "\x003" en tus "".


38
2017-11-04 19:52



No iba a tocar el timbre, pero veo que se arroja algo de información incorrecta aquí.

Yo, personalmente, prefiero string.Empty. Esa es una preferencia personal, y me atengo a la voluntad del equipo con el que trabajo, caso por caso.

Como algunos otros han mencionado, no hay diferencia en absoluto entre string.Empty y String.Empty.

Además, y este es un hecho poco conocido, el uso de "" es perfectamente aceptable. Cada instancia de "" creará un objeto en otros entornos. Sin embargo, .NET interna sus cadenas, por lo que las instancias futuras extraerán la misma cadena inmutable del grupo interno, y cualquier impacto en el rendimiento será insignificante. Fuente: Brad Abrams.


18
2017-11-04 20:07



Yo personalmente prefiero "" a menos que haya una buena razón para algo más complejo.


13
2017-11-04 19:50



String.Empty y string.Empty son equivalentes. String es el nombre de la clase BCL; string es su alias C # (o atajo, si lo desea). Lo mismo que con Int32 y int. Ver los documentos para más ejemplos.

Hasta "" está preocupado, no estoy realmente seguro.

Personalmente, siempre uso string.Empty.


12
2017-11-04 19:53



Casi todos los desarrolladores saben lo que "" significa. Personalmente me encontré con String.Empty la primera vez y tuve que pasar un tiempo buscando en Google para averiguar si realmente son exactamente lo mismo


10
2018-05-31 19:34



Este tema es bastante antiguo y largo, así que disculpe si este comportamiento se ha mencionado en otro lado. (Y apúntame a la respuesta que cubre esto)

He encontrado una diferencia en el comportamiento del compilador si usa string.Empty o comillas dobles La diferencia se muestra si no usa la variable de cadena inicializada con una cadena. Vacío o con comillas dobles.

En caso de inicialización con string.Empty entonces la advertencia del compilador

CS0219 - The variable 'x' is assigned but its value is never used

nunca se emite, mientras que en caso de inicialización con comillas dobles se obtiene el mensaje esperado.

Este comportamiento se explica en el artículo de Connect en este enlace: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value 

Básicamente, si lo hago bien, quieren permitir que un programador establezca una variable con el valor de retorno de una función para depuración sin molestarlo con un mensaje de advertencia y, por lo tanto, limitaron la advertencia solo en caso de asignaciones y cadenas continuas. Vacío no es una constante sino un campo.


7
2018-04-29 21:09



Realicé esta prueba muy simple usando la siguiente función en una aplicación de consola:

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
}

Esto sugiere claramente que las tres variables son str1, str2 y str3 aunque se inicializaron usando una sintaxis diferente, pero apuntan al objeto exactamente la misma cadena (de longitud cero) en la memoria. Realicé esta prueba en la aplicación de consola .Net 4.5. Por lo tanto, internamente no tienen ninguna diferencia y todo se reduce a la conveniencia de cuál quieres usar como programador. Este comportamiento de la clase de cuerda se conoce como cadena de prácticas en la red. Eric Lippert tiene un blog muy agradable aquí describiendo este concepto


7
2017-10-12 12:37