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?

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

Otras respuestas sugieren que se crea una nueva cadena cada vez que usa "" . 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: masiva, masivamente 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 de que "" y " " se confunden fácilmente el uno con el otro realmente no funciona conmigo. A menos que esté usando una fuente proporcional (y no he trabajado con desarrolladores que sí lo hagan) es bastante fácil notar la diferencia.

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, qué string.Empty usa el código de operación 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 

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

La naturaleza fundamental de la encoding es que nuestra tarea, como progtwigdores, 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 largos sin ningún beneficio adicional, sin duda no hay claridad adicional, ya que expresan exactamente la misma información.

Una diferencia es que si usa una syntax de switch-case , no puede escribir case string.Empty: porque no es una constante. Obtiene un Comstacktion error : A constant value is expected

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

Prefiero el string a String . La elección de la string.Empty sobre "" es una cuestión de elegir uno y seguir con él. Ventaja de utilizar string.Empty es muy obvio a lo que se string.Empty , y no copia accidentalmente caracteres no imprimibles como "\x003" en su "" .

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 ninguna diferencia 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 .

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

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

En lo que se refiere a "" , no estoy realmente seguro.

Personalmente, siempre uso string.Empty .

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.

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 comstackdor si usas 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 then the Compiler Warning

 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 progtwigdor 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.

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, a saber, str1 , str3 y str3 aunque se inicializaron utilizando una syntax diferente, apuntan al objeto exactamente igual de 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 progtwigdor. Este comportamiento de la clase de cadena se conoce como intercesión de cadena en .Net. Eric Lippert tiene un blog muy bueno aquí que describe este concepto.

Cualquiera de los anteriores.

Hay muchas, muchas cosas mejores para pontificar. Tal como la corteza de color se adapta mejor a un árbol, creo que es marrón vago con matices de musgo dulce.

Yo prefiero String.Empty, aparte de las otras razones para asegurarme de que sepa de qué se trata y de que no ha eliminado accidentalmente los contenidos, sino principalmente para la internacionalización. Si veo una cadena entre comillas, siempre tengo que preguntarme si es un código nuevo y debería colocarse en una tabla de cadenas. Así que cada vez que se cambia / revisa el código, debe buscar “algo entre comillas” y sí, puede filtrar las cadenas vacías, pero le digo a las personas que es una buena práctica no poner comillas entre comillas a menos que sepa que no se localizarán .

Nadie mencionó que en VisualStudio String está codificado por colores de manera diferente que la cadena. Lo cual es importante para la legibilidad. Además, minúsculas se utiliza generalmente para los vars y el tipo, no es un gran problema, pero String.Empty es una constante y no una var o tipo.

Yo no hago la diferencia. El último es el más rápido para escribir 🙂

string es sinónimo de tipo System.String , son idénticos.

Los valores también son idénticos: string.Empty == String.Empty == ""

No usaría el carácter constante “” en el código, en lugar de la string.Empty o String.Empty . String.Empty : más fácil de ver a qué se refería el progtwigdor.

Entre string y String me gusta más la string minúsculas simplemente porque solía trabajar con Delphi durante muchos años y el estilo de Delphi es una string minúscula.

Entonces, si yo fuera tu jefe, string.Empty escribiendo una string.Empty

No importa, son exactamente lo mismo. Sin embargo, lo principal es que debes ser coherente

PD: lucho con este tipo de “qué es lo correcto” todo el tiempo.

Utilizo el tercero, pero de los otros dos, el primero parece menos extraño. string es un alias para String, pero verlos en una tarea se siente apagado.

Cualquiera de los dos primeros sería aceptable para mí. Evitaría el último porque es relativamente fácil introducir un error al poner un espacio entre las comillas. Este error en particular sería difícil de encontrar por observación. Suponiendo que no hay errores tipográficos, todos son semánticamente equivalentes.

[EDITAR]

Además, es posible que desee utilizar siempre una string o una String para coherencia, pero así soy yo.

Es totalmente una preferencia de estilo de código, de cómo .NET maneja cadenas. Sin embargo, aquí están mis opiniones 🙂

Siempre uso los nombres de BCL Type al acceder a métodos estáticos, propiedades y campos: String.Empty o Int32.TryParse(...) o Double.Epsilon

Siempre uso las palabras clave C # al declarar nuevas instancias: int i = 0; o string foo = "bar";

Raramente uso literales de cadena no declarados, ya que me gusta poder escanear el código para combinarlos en constantes con nombres reutilizables. El comstackdor reemplaza las constantes con los literales de todos modos, así que esta es una forma más de evitar cadenas mágicas / números y darles un poco más de significado con un nombre. Además, cambiar los valores es más fácil.

He sido testigo presencial de “” resultando en problemas (menores) dos veces. Una vez se debió a un error de un desarrollador junior nuevo en la progtwigción basada en equipos, y el otro era un error tipográfico simple, pero el hecho es utilizar una cadena. Vacilar habría evitado ambos problemas.

Sí, esto es una decisión bastante acertada, pero cuando un idioma te ofrece múltiples formas de hacer las cosas, tiendo a inclinarme hacia el que tiene la mayor supervisión del comstackdor y el cumplimiento más estricto del tiempo de comstackción. Eso no es “”. Se trata de express un propósito específico.

Si escribe string.EMpty o Strng.Empty, el comstackdor le deja saber que lo hizo mal. Inmediatamente. Simplemente no comstackrá. Como desarrollador, usted está citando la intención específica de que el comstackdor (u otro desarrollador) no puede malinterpretar de ninguna manera, y cuando lo hace incorrectamente, no puede crear un error.

Si escribe “” cuando quiere decir “” o viceversa, el comstackdor hace lo que le dice que haga. Otro desarrollador puede o no ser capaz de recoger su intención específica. Error creado

Mucho antes de string.Empty was a thing He usado una biblioteca estándar que definió la constante EMPTY_STRING. Todavía usamos esa constante en sentencias case donde string.Empty no está permitido.

Siempre que sea posible, ponga el comstackdor a trabajar para usted y elimine la posibilidad de error humano, sin importar cuán pequeño sea. OMI, esto supera la “legibilidad” como otros han citado.

Especificidad y cumplimiento del tiempo de comstackción. Es lo que es para la cena.

Yo preferiría string.Empty over String.Empty porque puedes usarlo sin necesidad de incluir un using System; en tu archivo.

En cuanto a la selección "" sobre la string.Empty . string.Empty , es preferencia personal y debe ser decidido por su equipo.

El comstackdor debería hacer que todos sean iguales a la larga. Elija un estándar para que su código sea fácil de leer, y quédese con él.

Estaba mirando un código y se me vino a la mente esta pregunta que había leído alguna vez antes. Esta es ciertamente una cuestión de legibilidad.

Considere el siguiente código C # …

 (customer == null) ? "" : customer.Name 

vs

 (customer == null) ? string.empty : customer.Name 

Personalmente, encuentro que este último es menos ambiguo y más fácil de leer.

Como lo señalaron otros, las diferencias reales son insignificantes.

Utilizo “” porque va a tener un color distintivamente amarillo en mi código … por alguna razón, String.Empty es todo blanco en mi tema de Visual Studio Code. Y creo que eso me importa más.

Creo que el segundo es “correcto”, pero para ser sincero, no creo que importe. El comstackdor debe ser lo suficientemente inteligente como para comstackr cualquiera de ellos con el mismo código de bytes exacto. Yo uso “” yo mismo.

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

Como lo implica David, la diferencia entre String.Empty y "" es bastante pequeña, pero hay una diferencia. "" realmente crea un objeto, es probable que se retire del grupo interno de cadenas, pero aún así … mientras que String.Empty no crea ningún objeto … por lo que si realmente está buscando la eficiencia de la memoria, sugiero String.Empty . Sin embargo, debes tener en cuenta que la diferencia es tan trival que nunca querrás verla en tu código …
En cuanto a System.String.Empty o string.Empty o String.Empty … mi nivel de atención es bajo 😉

La cadena vacía es como un conjunto vacío, solo un nombre que todos usan para llamar "" . También en los lenguajes formales, las cadenas creadas a partir de un alfabeto que tiene una longitud cero se llaman cadena vacía. Tanto el conjunto como la cadena tienen un símbolo especial. Cadena vacía: ε y conjunto vacío: ∅. Si desea hablar sobre esta cadena de longitud cero, la llamará cadena vacía para que todos sepan exactamente a qué se refiere. Ahora, en caso de que lo nombre la cadena vacía, ¿por qué no utilizar la cadena? string.Empty en el código, muestra que la intención es explícita. Lo malo es que no es una constante y, por lo tanto, no está disponible en todas partes, como en los atributos. (No es una constante por algunos motivos técnicos, consulte la fuente de referencia).

Si bien la diferencia es muy, MUY poca, la diferencia todavía existe.

1) “” crea un objeto mientras que String.Empty no. Pero este objeto se creará una vez y se hará referencia desde el grupo de cadenas más adelante si tiene otro “” en el código.

2) String y string son lo mismo, pero recomendaría usar String.Empty (así como String.Format, String.Copy etc.) ya que la notación de puntos indica clase, no operador, y tener una clase que comience con mayúscula se ajusta a Estándares de encoding C #.