Para um caso simples em que é uma concatenação única simples, sinto que não vale a pena a complexidade de string.Format(e não testei, mas suspeito que para um caso simples como este, string.Format pode ser um pouco mais lento, com a análise de string de formato e tudo). Como Jon Skeet, prefiro não chamar explicitamente .ToString(), já que isso será feito implicitamente pela string.Concat(string, object)sobrecarga, e acho que o código tem uma aparência mais limpa e mais fácil de ler sem ele.
Mas para mais do que algumas concatenações (quantas são subjetivas), eu definitivamente prefiro string.Format. A certa altura, acho que tanto a legibilidade quanto o desempenho sofrem desnecessariamente com a concatenação.
Se houver muitos parâmetros para a string de formato (novamente, "muitos" é subjetivo), geralmente prefiro incluir índices comentados nos argumentos de substituição, para não perder o controle de qual valor vai para qual parâmetro. Um exemplo inventado:
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]
);
Atualizar
Ocorre-me que o exemplo que eu dei é um pouco confuso, porque parece que eu usei tanto concatenação e string.Formataqui. E sim, lógica e lexicamente, foi o que fiz. Mas as concatenações serão todas otimizadas pelo compilador 1 , já que são todas strings literais. Portanto, em tempo de execução, haverá uma única string. Portanto, devo dizer que prefiro evitar muitas concatenações em tempo de execução .
É claro que a maior parte deste tópico está desatualizado agora, a menos que você ainda esteja preso ao uso do C # 5 ou mais antigo. Agora temos strings interpoladas , que para facilitar a leitura, são muito superiores string.Format, em quase todos os casos. Atualmente, a menos que esteja apenas concatenando um valor diretamente no início ou no final de um literal de string, quase sempre uso a interpolação de string. Hoje, eu escreveria meu exemplo anterior assim:
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"
);
Você perde a concatenação de tempo de compilação dessa maneira. Cada string interpolada é transformada em uma chamada para string.Formatpelo compilador e seus resultados são concatenados em tempo de execução. Isso significa que é um sacrifício do desempenho do tempo de execução para facilitar a leitura. Na maioria das vezes, é um sacrifício que vale a pena, porque a penalidade do tempo de execução é insignificante. No código de desempenho crítico, entretanto, você pode precisar criar perfis de soluções diferentes.
1
Você pode ver isso na especificação C # :
... as seguintes construções são permitidas em expressões constantes:
...
- O operador binário + ... predefinido ...
Você também pode verificar isso com um pequeno código:
const string s =
"This compiles successfully, " +
"and you can see that it will " +
"all be one string (named `s`) " +
"at run time";