sirve - En C#, ¿debería usar string.Empty o String.Empty o “” para inicializar una cadena?
string.empty java (29)
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?
Casi todos los desarrolladores sabrán lo que significa "". Personalmente me encontré con String.Empty la primera vez y tuve que dedicar un tiempo a buscar en google para descubrir si realmente son exactamente lo mismo.
Creo que el segundo es "correcto", pero para ser honesto, no creo que importe. El compilador debe ser lo suficientemente inteligente como para compilar cualquiera de ellos al mismo bytecode exacto. Yo uso "" yo mismo.
Cualquiera de los anteriores.
Hay muchas, muchas cosas mejores para pontificar. Como el color de la corteza que mejor se adapta a un árbol, creo que es marrón vago con matices de musgo dulce.
Cualquiera de los dos primeros sería aceptable para mí. Yo 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 haya errores tipográficos, todos son semánticamente equivalentes.
[EDITAR]
Además, es posible que desee utilizar siempre la string o la String para String coherencia, pero eso es solo yo.
El compilador debería hacerlos todos iguales a largo plazo. Elija un estándar para que su código sea fácil de leer y apéguese a él.
En http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :
Como David sugiere, la diferencia entre
String.Emptyy""es bastante pequeña, pero hay una diferencia.""realidad crea un objeto, es probable que seString.Emptygrupo interno de la cadena, pero aún así ... mientrasString.Emptyno crea ningún objeto ... así que si realmente está buscando la eficiencia de la memoria, sugieroString.EmptySin embargo, debes tener en cuenta que la diferencia es tan trival que nunca verás en tu código ...
En cuanto aSystem.String.Emptyostring.EmptyoString.Empty... mi nivel de atención es bajo ;-)
Es totalmente una preferencia de estilo de código, como la forma en que .NET maneja las cadenas. Sin embargo, aquí están mis opiniones :)
Siempre utilizo los nombres de tipo BCL cuando String.Empty métodos, propiedades y campos String.Empty : String.Empty o Int32.TryParse(...) o Double.Epsilon
Siempre uso las palabras clave C # cuando declaro nuevas instancias: int i = 0; o string foo = "bar";
Raramente utilizo literales de cadena no declarados, ya que me gusta poder escanear el código para combinarlos en constantes reutilizables. El compilador reemplaza las constantes con los literales de todos modos, así que esta es más una forma de evitar cadenas / números mágicos y darles un poco más de significado con un nombre. Además, cambiar los valores es más fácil.
Este tema es bastante antiguo y largo, así que discúlpeme si este comportamiento se ha mencionado en otra parte. (Y señalarme la respuesta que cubre esto)
He encontrado una diferencia en el comportamiento del compilador si usas string.Empty o comillas dobles. La diferencia se muestra a sí misma si no utiliza la variable de cadena inicializada con cadena. Vacía 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 el caso de la 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 propósitos de depuración sin molestarlo con un mensaje de advertencia y, por lo tanto, limitaron la advertencia solo en caso de asignaciones de personal y cadena. El vacío no es una constante sino un campo.
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 tienen longitud cero se denominan cadenas vacías. Tanto el conjunto como la cadena tienen un símbolo especial para ello. Cadena vacía: ε y conjunto vacío: ∅. Si quieres hablar sobre esta cadena de longitud cero, la llamarás cadena vacía para que todos sepan exactamente a qué te refieres. Ahora, en caso de que le string.Empty nombre de cadena vacía, ¿por qué no usa string.Empty ? El inconveniente 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 algunas razones técnicas, consulte la fuente de referencia).
Mientras que la diferencia es muy, MUY pequeña, la diferencia todavía existe.
1) "" crea un objeto mientras que String.Empty no lo hace. Pero este objeto se creará una vez y se referenciará desde el conjunto de cadenas más adelante si tiene otro "" código.
2) La cadena y la cadena son iguales, 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 la clase que comienza con mayúscula se ajusta a Normas de codificación C #.
Nadie mencionó que en VisualStudio String tiene un código de color diferente al de la cadena. Lo que es importante para la legibilidad. Además, la minúscula se usa generalmente para vars y tipo, no es un gran problema, pero String.Empty es una constante y no una var o tipo.
No iba a intervenir, pero estoy viendo información errónea lanzada aquí.
Yo, personalmente, prefiero la string.Empty . string.Empty . Esa es una preferencia personal, y me inclino por la voluntad de cualquier equipo con el que trabaje caso por caso.
Como algunos otros han mencionado, no hay ninguna diferencia entre string.Empty y String.Empty .
Además, y esto es un hecho poco conocido, usar "" es perfectamente aceptable. Cada instancia de "", en otros entornos, creará un objeto. Sin embargo, .NET interna sus cadenas, por lo que las instancias futuras extraerán la misma cadena inmutable del grupo de pasantes, y cualquier impacto en el rendimiento será despreciable. Fuente: Brad Abrams .
No importa, son exactamente lo mismo. Sin embargo, lo principal es que debes ser consistente.
PD: Lucho con este tipo de "cuál es lo correcto" todo el tiempo.
Personalmente prefiero "" a menos que haya una buena razón para algo más complejo.
Preferiría una string a una String . string.Empty una string.Empty sobre "" es una cuestión de elegir una y seguirla. La ventaja de usar string.Empty es que es muy obvio lo que quiere decir, y no copia accidentalmente sobre caracteres no imprimibles como "/x003" en su "" .
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 , str3 y str3 aunque se inicializan con una sintaxis diferente, pero apuntan a la misma cadena (de longitud cero) en la memoria. Realicé esta prueba en la aplicación de consola .Net 4.5. Por lo que internamente no tienen ninguna diferencia y todo se reduce a la conveniencia de cuál desea utilizar como programador. Este comportamiento de la clase de cadena se conoce como cadena interna en .Net. Eric Lippert tiene un blog muy bonito here describe este concepto.
Realmente no hay diferencia desde el punto de vista de rendimiento y código generado. En las pruebas de rendimiento, iban y venían entre una y otra más rápido y la otra, y solo por milisegundos.
Al mirar el código detrás de escena, realmente tampoco ves ninguna diferencia. La única diferencia está en la IL, que 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 nos fijamos en el ensamblaje que se produce, es exactamente el mismo.
Código C #
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 montaje
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
Solo estaba mirando un código y esta pregunta me vino a la mente, la cual había leído un poco 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 me parece que este último es menos ambiguo y más fácil de leer.
Como han señalado otros, las diferencias reales son insignificantes.
Una diferencia es que si usa una sintaxis de switch-case , no puede escribir una case string.Empty: porque no es una constante. Obtienes un Compilation error : A constant value is expected
Mira este enlace para obtener más información: string-empty-versus-empty-quotes
Uso el tercero, pero de los otros dos el primero parece menos extraño. string es un alias para String, pero verlos en una asignación se siente apagado.
Utilizo "" porque se coloreará distintivamente de color amarillo en mi código ... por algún motivo, String.Empty es todo blanco en mi tema de código de Visual Studio. Y creo que eso me importa más.
Yo no hago una diferencia. El último es el más rápido de escribir aunque :)
Yo personalmente he presenciado "" resultando en problemas (menores) dos veces. Una vez se debió a un error de un desarrollador junior nuevo en la programación basada en equipos, y el otro fue un simple error tipográfico, pero el hecho es que está utilizando string. El vacío habría evitado ambos problemas.
Sí, esto es en gran medida una decisión de juicio, pero cuando un lenguaje te da múltiples maneras de hacer las cosas, tiendo a inclinarme hacia la que tiene la mayor supervisión del compilador y la aplicación más estricta en tiempo de compilación. Eso no es "". Se trata de expresar la intención específica.
Si escribe string.EMpty o Strng.Empty, el compilador le permite saber que lo hizo mal. Inmediatamente. Simplemente no compilará. Como desarrollador, usted está citando la intención específica de que el compilador (u otro desarrollador) no puede malinterpretar de ninguna manera, y cuando lo hace mal, no puede crear un error.
Si escribe "" cuando quiere decir "" o viceversa, el compilador hace lo que usted le dijo que hiciera. Otro desarrollador puede o no ser capaz de captar su intención específica. Bug creado.
Mucho antes de que string.Empty fuera algo, he usado una biblioteca estándar que define la constante EMPTY_STRING. Todavía utilizamos esa constante en las declaraciones de casos en que string.Empty no está permitido.
Siempre que sea posible, ponga el compilador a trabajar para usted y elimine la posibilidad de error humano, sin importar cuán pequeño sea. OMI, esto triunfa sobre la "legibilidad" como otros han citado.
Especificidad y compilación del tiempo de ejecución. Es lo que hay para cenar.
Yo preferiría string.Empty sobre String.Empty porque puede usarlo sin necesidad de incluir un using System; en tu archivo
En cuanto a la selección "" sobre string.Empty . string.Empty , es una preferencia personal y debe ser decidida por su equipo.
Yo prefiero String.Empty, aparte de las otras razones para asegurarte de que sabes lo que es y de que no hayas eliminado los contenidos accidentalmente, sino principalmente para la internacionalización. Si veo una cadena entre comillas, siempre tengo que preguntarme si ese es un código nuevo y debería colocarse en una tabla de cadenas. Por lo tanto, 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 la gente que es una buena práctica nunca poner cadenas entre comillas a menos que sepa que no se localizará. .
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. […] Empieza con brevedad. Aumente las otras dimensiones según lo requerido por la prueba.
En consecuencia, menos código es mejor código: string.Empty "" a string.Empty o String.Empty . Esos dos son seis veces más largos sin ningún beneficio adicional; ciertamente no hay claridad adicional, ya que expresan exactamente la misma información.
String.Empty y string.Empty son equivalentes. String es el nombre de la clase BCL; string es su alias de C # (o acceso directo, si lo desea). Igual que con Int32 y int . Vea la documentación para más ejemplos.
En cuanto a "" se refiere, no estoy realmente seguro.
Personalmente, siempre uso string.Empty .
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 la constante de caracteres "" en el código, en lugar de string.Empty o String.Empty - más fácil de ver qué significaba el programador.
Entre la string y la String Me gusta más la string minúscula más 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
Use lo que sea más fácil para usted y su equipo.
Otras respuestas han sugerido que se crea una nueva cadena cada vez que se usa "" . Esto no es cierto: debido a la internación de cadenas, se creará una vez por ensamblaje o una vez por AppDomain (o posiblemente una vez para todo el proceso, no estoy seguro en ese frente). Esta diferencia es insignificante: masivamente, masivamente insignificante.
Lo que encuentre más legible es un asunto diferente, sin embargo. Es subjetivo y variará de persona a persona, por lo que le sugiero que averigüe cómo le gusta a la mayoría de las personas de su equipo, y todo eso con coherencia. Personalmente me parece "" más fácil de leer.
El argumento de que "" y " " se confunden fácilmente entre sí no se lava conmigo. A menos que esté usando una fuente proporcional (y no he trabajado con ningún desarrollador que sí lo haga) es muy fácil notar la diferencia.