Usando String.Format para coisas simples?

Question

Nos meus primeiros dias de programação .NET, usei string.format () apenas para concatenações complexas de string, por exemplo, para compilar strings como

Problema com o pedido do cliente 234 Data 2/2/2002 e ID de pagamento 55543.

Mas agora eu uso String.Format para quase todas as concatenação de strings que tenho que fazer, também simples, como prefixar uma string com alguma coisa.

Console.WriteLine(string.Format("\t\t{0}", myString));

Existe alguma sobrecarga possível sobre isso? Talvez eu deva usar o regular + Operador para fazer essas operações simples?

Qual é a sua opinião sobre isso?

Answer 1

Para concatenações simples de strings, use o + abordagem. É mais claro para coisas simples que não exigem um formato.

Para seqüências mais complexas que possuem um determinado formato e onde é útil manter a estrutura de toda a string e fornecer um espaço reservado para a entrada, use String.Format.

E sim, há uma sobrecarga. String.Format usa um StringBuilder embaixo das capas. Concatenações simples de string serão muito mais rápidas nesses cenários. Alguns parâmetros de referência e postagens de blog sobre esse tópico podem ser encontrados com bastante facilidade. Claro que tudo depende do seu uso. Se pequenas concativas de cordas estão ocorrendo em um loop, o uso repetido de String.Format provavelmente será mais perceptível do que um simples + Concat. Se você está construindo um ampla string em um loop, então o exemplo clássico é preferir StringBuilder e perguntas relacionadas sobre concat versus stringbuilder podem ser encontradas no SO.

EDITAR: Para esclarecer, isso serve pouco propósito: String.Format("{0}{1}", a, b) já que não há muita formatação. É simplesmente a + b. Infelizmente, encontrei esses exemplos no código de produção e, assim que vejo string.format, espero ver algo que precisa ser estruturado de uma certa maneira, não um concat direto.

OTOH, considere este número de telefone: "(" + area + ") " + number + " x" + extension - Há muita coisa acontecendo e não é fácil de modificar. Nesse caso, um string.format é preferível: String.Format("({0}) {1} x{2}", area, number, extension). Este ainda é um exemplo trivial, mas você entendeu a ideia.

Answer 2

Eu também tendem a usar String.Format na maioria das operações, que precisam de duas ou mais strings/valores a serem combinadas, pois produzem mais fáceis de ler do que iniciar e interromper strings com +s no meio.

Expandir

string value = string.Format("Hello {0}", user.username);

é muito mais legível e expansível do que

string value = "Hello" + user.username

Por exemplo, se você quiser adicionar a última data de login como uma atualização do sistema, você pode simplesmente expandir o código para o seguinte

string value = string.Format("Hello {0}, you last logged in {1}", user.username, user.lastLogin);

Answer 3

Concatenação simples é mais eficiente para coisas simples. Usar String.Format() pois quando as coisas ficam mais complicadas e facilita a leitura do seu código.

Pessoalmente, faço a mesma coisa (desde que a função que estou chamando não lide com a formatação para mim).

---

Clarrificação

Para concatenação regular de string como "Hello " + "World!"; Eu usaria um StringBuilder. Seu exemplo formata a string para saída, prevendo duas guias ... que eu considero mais como formatação.

Há uma diferença entre formatação e concatenação ... tenha cuidado com o que você usa para qual.

---

String.Format() Usa um StringBuilder internamente para que a concatenação seja mais eficiente do que fazer concatenação regular de string de qualquer maneira.

Você pode querer mudar seu exemplo desde Console.WriteLine() pode lidar com a própria formatação (não String.Format() precisava):

Console.WriteLine("\t\t{0}", myString);

Answer 4

Minha regra é se eu tiver que usar o + (concatenação) mais de uma vez eu mudo para um string.Format.

string a = "Something: " + x;   // ok

string b = "Something: " + x + " something else"; // change it to a string.Format
string bB = string.Format("Something: {0} something else", x); // much nicer to read

string c = "Something: " + x + " " + y + " " + z;  // Yuck
string cC = string.Format("Something: {0} {1} {2}", x, y, x);  // Much nicer

Answer 5

Não sei sobre o desempenho, alguém provavelmente fornecerá esses dados, mas meu sentimento é que String.Format é o caminho a percorrer se você quiser colocar a sequência de formato em seu arquivo de configuração (ou campo de banco de dados ou arquivo de recurso ou qualquer outra coisa) . Dessa forma, se você quiser ajustar o número de guias, mude para espaços, adicione delimitadores ou o que quer que seja, não precisa recompilar.

Answer 6

Eu costumo usar String.Concat ao invés de String.Format Quando eu só preciso prefixar ou sufixo uma determinada string. Eu prefiro a chamada explícita para o Concatmétodo então para usar o + operador e se você já estiver usado String.Format É apenas uma questão de trocar de tecla.

Iirc, o String.Concat o método será o mesmo que usar o operador para que também seja mais rápido do que String.Format.

Answer 7

Quase sempre uso o formato, embora use um método de extensão em vez do método estático da string. Acho mais fácil de entender, mais fácil de mudar e geralmente mais fácil de manter. Também pode facilitar a localização porque não apresenta problemas de pedidos da maneira que a concatenação faz.

Honestamente, o que parece melhor?

"You have {0} widgets.".Frmt(widgetCount)
"You have " + widgetCount.ToString() + " widgets."