C#: concatenación de cadenas más legible. las mejores prácticas

Question

Duplicar posible:
How should I concatenate strings?

Hay varias maneras de ConCat cadenas en las tareas cotidianas cuando el rendimiento no es important.

• result = a + ":" + b
• result = string.Concat(a, ":", c)
• result = string.Format("{0}:{1}", a, b);
• StringBuilder approach
• ...?

¿Qué prefiere y por qué si la eficiencia no es importante pero desea mantener el código más legible para su gusto?

Answer 1

string.Format para mí, pero en la práctica uso lo que sea apropiado para el propósito, teniendo en cuenta el rendimiento y la legibilidad.

Si fueran dos variables las usaría.

string.Concat(str1, str2);

Si contenía una constante o algo que requiere el formato a continuación.

string.Format("{0} + {1} = {2}", x, y, x + y);

O para algo así como una consulta SQL

string SqlQuery = "SELECT col1, col2, col3, col4" + 
        "FROM table t " + 
        "WHERE col1 = 1"; 

Y generador de cadenas de conseguir un alto rendimiento.

Answer 2

String.Format(...) es el más lento.

Para concatenaciones simples que no tienen lugar en un bucle, use String.Concat(...) o el operador +, que se traduce en el mismo debajo del capó, afaik. Lo que es más legible es muy subjetivo.

El uso de StringBuilder para concatenaciones simples es exagerado para concatenaciones sencillas y tiene muy probablemente demasiada sobrecarga. Solo lo usaría en un bucle.

Answer 3

• string.Format

  de unos concats. para más utilizo

• enfoque StringBuilder

incluso si el rendimiento no es importante. hay un acuerdo de equipo que tengo que seguir

Answer 4

Para algo como esto (que supongo que se enviará a la interfaz de usuario), definitivamente preferiría String.Format.Permite que la cadena sea internacionalizada fácil; puede grep para llamadas al String.Format y reemplazarlos con su formato de traducción.

Answer 5

Mi preferencia personal es:

encuentro el + acercarse la más legible y sólo utilizar el formato() o un StringBuilder si hay una buena razón (i18n, rendimiento, etc.) para ello. Yo (casi) nunca uso Concat.

Creo que el método + me resulta más fácil de leer que Format() simplemente porque no tengo que saltar hasta el final para ver qué variables se colocan en los {} marcadores de posición. Y si los place-titders no están en orden numérico, es aún más difícil leer imo.

Pero supongo que para proyectos más grandes tiene sentido simplemente hacer cumplir el uso de Format con una guía de estilo en caso de que el código pueda ser (re) utilizado en un proyecto que requiera i18n más adelante.

Answer 6

Depende del uso. Cuando solo desea usar dos cadenas, utilizar a + b es mucho más legible que string.Format("{0}{1}", a, b). Sin embargo, cada vez es más complejo, prefiero usar string.Format. Compare esto:

string x = string.Format("-{0}- ({1})", a, b); 

contra:

string x = "-" + a + "- (" + b + ")"; 

Creo que en la mayoría de los casos, es muy fácil de detectar la forma más legible para hacer las cosas. En los casos en que es discutible cuál es más legible, solo elija uno, porque su jefe no está pagando por estas discusiones inútiles ;-)

Answer 7

Prefiero String.Format para cadenas pequeñas, y StringBuilder para las más grandes. Mi razón principal es la legibilidad. Me resulta mucho más fácil usar String.Format (o StringBuilder.AppendFormat()), pero debo admitir que eso es solo una preferencia personal.

Para la generación de texto realmente grande, es posible que desee considerar el uso de las nuevas plantillas preprocesadas (VS2010) T4: son realmente agradables.

Además, si alguna vez está en VB.NET, me gusta la técnica literal de XML de la que habló Kathleen Dollard en episode 152 of hanselminutes.

Answer 8

prefieren utilizar:

String.Concat para concatenaciones simples como String.Concat("foo", bar);

String.Format para el formateo complejo como String.Format("<a href=\"{0}\">{1}</a>", url, text);

StringBuilder para concatenaciones masivos como:

var sb = new StringBuilder(); 
sb.AppendLine("function fooBar() {"); 
sp.AppendLine(String.Join(Environment.NewLine, blah)); 
sp.AppendLine("}"); 
page.RegisterClientScript(page.GetType(), sb.ToString()); 

prefieren evitar "foo" + "bar" (así como if (foo == "bar"). Y especialmente String.Format("{0}{1}", foo, bar) y

throw new Exception("This code was" + 
    "written by developer with" + 
    "13\" monitor");