I have a loop with thousands of results that renders a table. The string is mounted through the StringBuilder in this way (example snippet):
%pre%Can there be any performance improvement if I put the whole code in one line, as below?
%pre%And if it were a concatenation, such as the following code?
%pre%More advanced explanations of how language works are welcome.
The best will always be to keep in a String that is unique at compile time rather than at runtime.
And, believe it or not, in C # you can use line breaks in a single String using the character %code% (at) at the beginning of it.
%pre%Also, according to this topic in SO , if you concatenate String literals in a same command, they will be concatenated at compile time, then it would give the same effect on runtime performance something like:
%pre%Using %code% to concatenate String literals will decrease program performance, since it will prevent the compiler from optimizing literals.
On the other hand, if the compiler can not know the size of the String at compile time, for example if we concatenate variables, %code% is usually faster than directly concatenating the values. I say "generally" because I do not really know how much the compiler or CPU would be able to optimize certain exceptional cases.
In case of substituting multiple calls from %code% to only one, the gain will be minimal.
On one occasion, working with the class %code% , I noticed a great improvement in performance when booting the %code% with a size sufficient to store the entire result. I did this using two routines, one to count the required size, and another to build the string.
To initialize the StringBuilder with a size simply pass an integer in the con- tractor:
%pre%It has been properly said that the best way is to use a single %code% in the case presented. It's fast and legible.
But if there is a reason to do sequential concatenation, it can be used without performance problems. It ends up becoming a single %code% at compile time. The only problem is being less readable.
There is optimization of the compiler in many cases. But not at all. If all of the% s sizes involved are not known, there is not so much optimization. In these cases the optimization only transforms the concatenations in the %code% method. It is certainly better because it avoids unnecessary allocations, but the size calculation is still needed.
Although the %code% property is of type %code% , I have doubts if it can be so optimized.
If it is useful a %code% may be appropriate and not have a performance impairment. It may even be faster than a method %code% of %code% . When you know the total size required for all% s of% s in a simple way, possibly as a constant literal, %code% is very fast. Internally %code% uses a %code% so you find that the former is faster that the second one does not make sense. Of course, in cases that have only 4% with% s the concatenation is made simpler without %code% .
But so far little has been added to what has been said in the other answers.
There are cases to make work easier, the text should not be in the code. It should be in an external file, when this is pertinent, or be in Resources . It may be easier to maintain in this and it is very fast in the second case.
For everything there is the best solution applied. This is a case that easier maintenance can be more important than performance. In case of catching the resource the performance will not be much affected either. And even if it is, it will not create problem for the application. This performance concern makes sense for cases of extreme strings manipulations . In the case of file access the performance will obviously be affected by access to mass memory. But it will still not affect the application. Of course this solution should only be chosen when you want to be able to change the text easily after compilation, when you want to give this freedom to the user.
I have a loop with thousands of results that renders a table. The string is mounted through the StringBuilder in this way (example snippet):
ScriptTbody.AppendLine("</select>");
ScriptTbody.AppendLine("<p class=\"valAnoInicio\"></p>");
ScriptTbody.AppendLine("</td>");
ScriptTbody.AppendLine("<td>");
ScriptTbody.AppendLine("<select class=\"cbPeriodoIniEdit\">");
ScriptTbody.AppendLine("</select>");
ScriptTbody.AppendLine("<p class=\"valPeriodoInicio\"></p>");
ScriptTbody.AppendLine("</td>");
Can there be any performance improvement if I put the whole code in one line, as below?
ScriptTbody.AppendLine("</select><p class=\"valAnoInicio\"></p></td><td><select class=\"cbPeriodoIniEdit\"></select><p class=\"valPeriodoInicio\"></p></td>");
And if it were a concatenation, such as the following code?
comand.CommandText = "SELECT ";
comand.CommandText += " TI.COD_INDICADOR, ";
comand.CommandText += " TI.TXT_DESCRICAO, ";
comand.CommandText += " TI.COD_PRODUTO, ";
comand.CommandText += "FROM ";
comand.CommandText += " TB_INDICADOR TI";
More advanced explanations of how language works are welcome.
The best will always be to keep in a String that is unique at compile time rather than at runtime.
And, believe it or not, in C # you can use line breaks in a single String using the character @ (at) at the beginning of it.
string query =
@"SELECT
TI.COD_INDICADOR,
TI.TXT_DESCRICAO,
TI.COD_PRODUTO,
FROM
TB_INDICADOR TI";
Also, according to this topic in SO , if you concatenate String literals in a same command, they will be concatenated at compile time, then it would give the same effect on runtime performance something like:
comand.CommandText =
"SELECT " +
" TI.COD_INDICADOR, " +
" TI.TXT_DESCRICAO, " +
" TI.COD_PRODUTO, " +
"FROM " +
" TB_INDICADOR TI";
Using StringBuilder to concatenate String literals will decrease program performance, since it will prevent the compiler from optimizing literals.
On the other hand, if the compiler can not know the size of the String at compile time, for example if we concatenate variables, StringBuilder is usually faster than directly concatenating the values. I say "generally" because I do not really know how much the compiler or CPU would be able to optimize certain exceptional cases.
In case of substituting multiple calls from StringBuilder.Append to only one, the gain will be minimal.
On one occasion, working with the class StringBuilder , I noticed a great improvement in performance when booting the StringBuilder with a size sufficient to store the entire result. I did this using two routines, one to count the required size, and another to build the string.
To initialize the StringBuilder with a size simply pass an integer in the con- tractor:
int tamanho = CalculaEspacoNecessario();
var sb = new StringBuilder(tamanho);
PreencherStringBuilder(sb);
It has been properly said that the best way is to use a single string in the case presented. It's fast and legible.
But if there is a reason to do sequential concatenation, it can be used without performance problems. It ends up becoming a single string at compile time. The only problem is being less readable.
There is optimization of the compiler in many cases. But not at all. If all of the% s sizes involved are not known, there is not so much optimization. In these cases the optimization only transforms the concatenations in the string method. It is certainly better because it avoids unnecessary allocations, but the size calculation is still needed.
Although the concat() property is of type SqlCommand.CommandText , I have doubts if it can be so optimized.
If it is useful a string may be appropriate and not have a performance impairment. It may even be faster than a method StringBuilder of concat() . When you know the total size required for all% s of% s in a simple way, possibly as a constant literal, string is very fast. Internally string uses a StringBuilder so you find that the former is faster that the second one does not make sense. Of course, in cases that have only 4% with% s the concatenation is made simpler without concat() .
But so far little has been added to what has been said in the other answers.
There are cases to make work easier, the text should not be in the code. It should be in an external file, when this is pertinent, or be in Resources . It may be easier to maintain in this and it is very fast in the second case.
For everything there is the best solution applied. This is a case that easier maintenance can be more important than performance. In case of catching the resource the performance will not be much affected either. And even if it is, it will not create problem for the application. This performance concern makes sense for cases of extreme strings manipulations . In the case of file access the performance will obviously be affected by access to mass memory. But it will still not affect the application. Of course this solution should only be chosen when you want to be able to change the text easily after compilation, when you want to give this freedom to the user.