Question

I’m working with huge string data for a project in C#. I’m confused about which approach should I use to manipulate my string data.

First Approach:

StringBuilder myString = new StringBuilder().Append(' ', 1024);

while(someString[++counter] != someChar)
    myString[i++] += someString[counter];

Second Approach:

String myString = new String();

int i = counter;
while(soumeString[++counter] != someChar);
myString = someString.SubString(i, counter - i);

Which one of the two would be more fast(and efficient)? Considering the strings I’m working with are huge.

The strings are already in the RAM.
The size of the string can vary from 32MB-1GB.

Answer 1

Per request from OP, here are my test results.

Assumptions:

• Big string is already in memory, no requirement for reading from disk
• Goal is to not use any native pointers/unsafe blocks

• The “checking” process is simple enough that something like Regex is not needed. For now simplifying to a single char comparison. The below code can easily be modified to consider multiple chars at once, this should have no effect on the relative performance of the two approaches.

  public static void Main()
  {
      string bigStr = GenString(100 * 1024 * 1024);
  
      Stopwatch sw = Stopwatch.StartNew();
      for (int i = 0; i < 10; i++)
      {
          int counter = -1;
          StringBuilder sb = new StringBuilder();
          while (bigStr[++counter] != 'x')
              sb.Append(bigStr[counter]);
          Console.WriteLine(sb.ToString().Length);
      }
      sw.Stop();
      Console.WriteLine("StringBuilder: {0}", sw.Elapsed.TotalSeconds);
  
      sw = Stopwatch.StartNew();
      for (int i = 0; i < 10; i++)
      {
          int counter = -1;
          while (bigStr[++counter] != 'x') ;
  
          Console.WriteLine(bigStr.Substring(0, counter).Length);
      }
      sw.Stop();
      Console.WriteLine("Substring: {0}", sw.Elapsed.TotalSeconds);
  }
  
  public static string GenString(int size)
  {
      StringBuilder sb = new StringBuilder(size);
      for (int i = 0; i < size - 1; i++)
      {
          sb.Append('a');
      }
      sb.Append('x');
      return sb.ToString();            
  }
  

Results (release build, .NET 4):

StringBuilder ~7.9 sec

Substring ~1.9 sec

StringBuilder was consistently > 3x slower, with a variety of different sized strings.