Para un caso simple en el que se trata de una simple concatenación única, creo que no vale la pena la complejidad de string.Format(y no lo he probado, pero sospecho que para un caso simple como este, string.Format podría ser un poco más lento, con el formato de análisis de cadenas y todo). Como Jon Skeet, prefiero no llamar explícitamente .ToString(), ya que la string.Concat(string, object)sobrecarga lo hará implícitamente , y creo que el código tiene un aspecto más limpio y es más fácil de leer sin él.
Pero para más de unas pocas concatenaciones (cuántas son subjetivas), definitivamente prefiero string.Format. En cierto punto, creo que tanto la legibilidad como el rendimiento sufren innecesariamente con la concatenación.
Si hay muchos parámetros en la cadena de formato (nuevamente, "muchos" es subjetivo), generalmente prefiero incluir índices comentados en los argumentos de reemplazo, para que no pierda la pista de qué valor va a qué parámetro. Un ejemplo artificial:
Console.WriteLine(
"Dear {0} {1},\n\n" +
"Our records indicate that your {2}, \"{3}\", is due for {4} {5} shots.\n" +
"Please call our office at 1-900-382-5633 to make an appointment.\n\n" +
"Thank you,\n" +
"Eastern Veterinary",
/*0*/client.Title,
/*1*/client.LastName,
/*2*/client.Pet.Animal,
/*3*/client.Pet.Name,
/*4*/client.Pet.Gender == Gender.Male ? "his" : "her",
/*5*/client.Pet.Schedule[0]
);
Actualizar
Se me ocurre que el ejemplo que he dado es un poco confuso, porque parece que he usado tanto la concatenación como string.Formataquí. Y sí, lógica y léxicamente, eso es lo que he hecho. Pero todas las concatenaciones serán optimizadas por el compilador 1 , ya que todas son cadenas literales. Entonces, en tiempo de ejecución, habrá una sola cadena. Así que supongo que debería decir que prefiero evitar muchas concatenaciones en tiempo de ejecución .
Por supuesto, la mayor parte de este tema está desactualizado ahora, a menos que todavía esté atascado con C # 5 o anterior. Ahora tenemos cadenas interpoladas , que en términos de legibilidad, son muy superiores a string.Format, en casi todos los casos. En estos días, a menos que solo esté concatenando un valor directamente al principio o al final de un literal de cadena, casi siempre uso la interpolación de cadenas. Hoy, escribiría mi ejemplo anterior así:
Console.WriteLine(
$"Dear {client.Title} {client.LastName},\n\n" +
$"Our records indicate that your {client.Pet.Animal}, \"{client.Pet.Name}\", " +
$"is due for {(client.Pet.Gender == Gender.Male ? "his" : "her")} " +
$"{client.Pet.Schedule[0]} shots.\n" +
"Please call our office at 1-900-382-5633 to make an appointment.\n\n" +
"Thank you,\n" +
"Eastern Veterinary"
);
De esta manera, pierde la concatenación en tiempo de compilación. El string.Formatcompilador convierte cada cadena interpolada en una llamada a , y sus resultados se concatenan en tiempo de ejecución. Eso significa que esto es un sacrificio del rendimiento en tiempo de ejecución para mejorar la legibilidad. La mayoría de las veces, es un sacrificio que vale la pena, porque la penalización en tiempo de ejecución es insignificante. En el código de rendimiento crítico, sin embargo, es posible que deba perfilar diferentes soluciones.
1
Puede ver esto en la especificación de C # :
... las siguientes construcciones están permitidas en expresiones constantes:
...
- El operador binario predefinido + ...
También puedes verificarlo con un pequeño código:
const string s =
"This compiles successfully, " +
"and you can see that it will " +
"all be one string (named `s`) " +
"at run time";