Make String concatenation faster in C# [duplicate]

Answer 1

When you read a file byte by byte, it can take too long. I would recommend that you read a block of bytes (for example 1024 or 2048) in the loop. Then, in the block you have read, use a regular expression to match your character, particularly if you have a extremely large file.

Sample code would be something like this:

private string GetFileData(string fileName, string matchChar)
{
    StringBuilder x = new StringBuilder();
    int blockCount = 2048;
    int offset = 0;
    string pattern = matchChar;
    int k = -1;
    using (var sr = new System.IO.FileStream(fileName, System.IO.FileMode.Open))
    {
       while ((sr.CanRead) && (k != 0))
       {
           byte[] bt = new byte[blockCount];
           k = sr.Read(bt, 0, blockCount);
           string so = System.Text.UTF8Encoding.UTF8.GetString(bt);
           var m = new System.Text.RegularExpressions.Regex(pattern).Matches(so);
           foreach (System.Text.RegularExpressions.Match item in m)
           {
               x.Append(item.Value);
           }
       }
    }
    return x.ToString();
}

You would call this as

GetFileData(@"c:\matchtest.ono", "a");

Answer 2

Use StringBuilder, Strings are immutable in .net meaning that ever concatenation makes a copy of the string.

Using the StringBuilder Class (MSDN)

StringBuilder sb = new StringBuilder();
sb.Append("1") // like so

Answer 3

Use a StringBuilder.

var sb = new StringBuilder();
sb.Append("abc");
sb.Append("def");
var str = sb.ToString();

Answer 4

Use StringBuilder instead of string concatenations.

A StringBuilder object maintains a buffer to accommodate the concatenation of new data. New data is appended to the end of the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, then the new data is appended to the new buffer.

String on the contrary is immutable, every time you concatenate it creates a new object and throws away old ones, which is very inefficient.

Also, you might want to set high capacity for StringBuilder in advance, if you know that the result is going to be huge. This will reduce the number of buffer re-allocations.

Taking your pseudo-code it would look like this:

StringBulder x = new StringBuilder(10000); // adjust capacity to your needs

while (var < File.Length)
{
   if(File.Content[var] == "A")
      x.Append("1"); // or AppendLine, or AppendFormat
   else
      x.Append("2");
}

Answer 5

System.Text.StringBuilder is the type you want to use for string concatenation operations in a loop. It is going to be far more efficient. Use .Append(value) on the object during each iteration.

StringBuilder builder = new StringBuilder();

// and inside your loop 
{
    if (blah)
        builder.Append("1");
    else
        builder.Append("0");
}

string output = builder.ToString(); // use the final result

Answer 6

Use a StringBuilder instead, that will perform much better - using strings you create a new string each time within the loop which causes a lot of overhead/garbage collection, using a single StringBuilder that you create outside the loop you can avoid that.