Are there benefits to using string formatting versus string concatenation?

Question

Possible Duplicate:
C# String output: format or concat?

what is the benefit of using this:

Console.WriteLine("{0}: {1}", e.Code, e.Reason);

VS. this:

Console.WriteLine(e.Code + ": " + e.Reason);

????

Answer 1

The reason I always use .Format() is for readability and consequently bug reduction and maintenance benefits. Of course this makes no sense if you're relatively new to code as the second example is more intuitive at first. The first appears needlessly complex.

However if you choose the second pattern then you start to have problems when you have lots of variables. This is where it is easier to appreciate the benefits of the first pattern.

e.g

Console.Writeline(var1 + " " + var2 + "-" + var3 +
 " some sort of additional text" + var4);

Note the bug: I need another space after "text" but that's not easy to see in this example.

However if I do it the other way:

Console.Writeline("{0} {1}-{2} some sort of additional text{3}", 
 var1, var2, var3, var4)

It's clearer to see what's going on. Its easier to appreciate the final result when you split the formatting from the variables that are going to be used.

If we want to think even further long term then it helps with globalisation/customisation. If we put those format strings into config we can then change the formatting or ordering of the variables without touching the code.

Answer 2

For me, the benefits of the string.Format pendant are:

• Improved readability
• Better translatable

From a performance perspective, I did never do any measurements; it could well be that the concatenation is faster then the string.Format pendant.

Answer 3

Practically, the only difference is that the first allows you to control the layout

string.Format("*{0:3}*",1); // *  1*

or control formatting:

string.Format("*{0:c}*",1); // *$1.00*

The performance of concatenation can be considered when doing lots of it in tight loops, in which case StringBuilder.Append and StringBuilder.AppendFormat are both much preferred. AppendFormat and string.Format are very close, performance-wise, so there is no need to substitute the second for the first.

Answer 4

It boils down to "When is it better to use String.Format vs string concatenation".

See this question for the answer: When is it better to use String.Format vs string concatenation?

Answer 5

As strings are immutable (cant change an existing string must create a new one each time) string format can have performance benefits as it wont create as many memory references.

result = string1 + " " + string2 + " " + string3

This creates 10 references

• result
• string1
• string2
• string3
• " "
• " "
• string1 + " "
• string1 + " " + string2
• string1 + " " + string2 + " "
• string1 + " " + string2 + " " + string 3

result = string.Format("{0} {1} {2}", string1, string2, string3)

This creates 5 references

• result
• string1
• string2
• string3
• "{0} {1} {2}"