Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Christopher_G_Lewis — Wed, 02 Apr 2008 16:54:32 GMT

What was the size of your data set? Did you try it over different size files? SB should be much better for larger data sets, and I certainly wouldn't want to use a String if the size is over 85k (large object heap!)

What about the memory footprint of each one? String.Replace() is certainly going to leave a bunch of junk around that will need to be gc'd later.

Basically, this is a worthless statistical blip that fits *just* your dataset, and shouldn't be applied as a one-size-fits-all analysis.

Interesting Finds: April 2, 2008

Jason Haley — Wed, 02 Apr 2008 17:26:34 GMT

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

BlindWanderer — Wed, 02 Apr 2008 19:25:26 GMT

Have you tried running it with the RegexOptions.Compiled compiled flag? You should get better performance.

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Wed, 02 Apr 2008 21:38:47 GMT

Cristopher, we used files from 2 mb to over 6.5 mb. During the tests we inverted the sequence of execution. We haven't noticed anything abnormal with CPU. Like you, I was expecting to see SB surpassing the other two approaches. If you decide to try it and get different results, let me know, please.

BlidWanderer, I haven't tried it, but it's definitely a good idea to try. Have you tried it? I'm curious! :)

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Joel "Jaykul" Bennett — Thu, 03 Apr 2008 00:21:26 GMT

Sorry guys, but the test is wrong ...

The line $fileContent.Replace("\n", "") replaces *nothing* because \n is just a two character string in PowerShell. What you MEANT to test is: $fileContent.Replace("`n", "")

On top of that, the string "\n" is a regular expression PATTERN, which means it requires pattern matching -- something you CANNOT DO with either of the other two methods. You should try with "`n" in all three cases, that way you're just replacing a single character.

As a side note, *removing* single characters isn't really that great of a test anyway -- you should try *replacing* a whole word with a word of a different length -- maybe try replacing "Visual Basic" in that MSDN article you linked to with "VB" or something...

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Thu, 03 Apr 2008 00:48:11 GMT

Thanks for the correction! After testing with other special chars I made this mistake when rolling back to newline again.

Anyway, after fixing it the proportion didn't change. As you can see below String.Replace is the fastest approach.

We just replaced special characters, not words or regular characters, because that was the requirement for a particular function we were investigating. I totally agree with you that it's

not a full stress test and I mentioned this in the article.

Here are the results:

RegEx

PS C:\development\My Tools> measure-command { .\RegExReplacePerformance.ps1 test.txt }

Starting RegEx.Replace...

End!

Days : 0

Hours : 0

Minutes : 3

Seconds : 59 <-- Here!

Milliseconds : 907

Ticks : 2399070288

TotalDays : 0.00277670172222222

TotalHours : 0.0666408413333333

TotalMinutes : 3.99845048

TotalSeconds : 239.9070288

TotalMilliseconds : 239907.0288

StringBuilder:

PS C:\development\My Tools> measure-command { .\StringBuilderReplacePerformance.ps1 test.txt }

Starting StringBuilder.Replace...

End!

Days : 0

Hours : 0

Minutes : 0

Seconds : 34 <-- Here!

Milliseconds : 570

Ticks : 345702214

TotalDays : 0.000400118303240741

TotalHours : 0.00960283927777778

TotalMinutes : 0.576170356666667

TotalSeconds : 34.5702214

TotalMilliseconds : 34570.2214

String:

PS C:\development\My Tools> measure-command { .\StringReplacePerformance.ps1 test.txt }

Starting String.Replace...

End!

Days : 0

Hours : 0

Minutes : 0

Seconds : 20 <-- Here!

Milliseconds : 583

Ticks : 205835077

TotalDays : 0.000238235042824074

TotalHours : 0.00571764102777778

TotalMinutes : 0.343058461666667

TotalSeconds : 20.5835077

TotalMilliseconds : 20583.5077

Thanks

Interesting Finds: 2008.04.03

gOODiDEA — Thu, 03 Apr 2008 04:24:51 GMT

.NET:WorkingwithEvents,part1AFast/CompactSerializationFrameworkHowtosetanIISApplica...

Interesting Finds: 2008.04.03

gOODiDEA.NET — Thu, 03 Apr 2008 04:25:00 GMT

.NET: Working with Events, part 1 A Fast/Compact Serialization Framework How to set an IIS Application

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Joel "Jaykul" Bennett — Thu, 03 Apr 2008 06:59:58 GMT

It's me again ;-) there's still something wrong with that, because there's just no way the regex takes 8 times as long...

If the code you're using is exactly what you pasted, the problem is that you're passing an array of strings to [regex]::replace instead of a string. (to be fair, you should also be assigning the output to a variable, although it won't make much difference if you use Measure-Command)

try this:

$lines = gc $fileName

[string]$text = gc $fileName

and then run your [regex]::replace on $lines and on $text ... the array takes MUCH longer (depending mostly on what you replace)

My results (using the Get-PerformanceHistory script from PowerShellCentral.com/scripts):

Duration Average Commmand

-------- ------- --------

13.01577 0.13016 1..100 | ForEach { $out1 = [regex]::replace($lines,"`n","") }

3.21073 0.03211 1..100 | ForEach { $out2 = [regex]::replace($text,"`n","") }

2.81232 0.02812 1..100 | ForEach { $out3 = $text.replace("`n","") }

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Joel "Jaykul" Bennett — Thu, 03 Apr 2008 07:09:33 GMT

Incidentally ... I think it's clear by now that my corrections aren't meant to disprove the basic premise -- that string.replace is fastest -- it obviously is.

The only reason I bother with the correction is that the difference is very minor, not a multiple.

My point is just to make sure it's clear that under normal circumstances, you should be able to just use whatever format your string is already in -- because the time (and memory) it takes to convert from one to the other (and back?) is too big of an offset ;-)

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Thu, 03 Apr 2008 08:47:27 GMT

Hi Joel,

I'm using a text file that is, in fact, a License Agreement:

"License Agreement

This License Agreement describes the rights and responsibilities of anyone using XXX.

THIS IS AN AGREEMENT BETWEEN YOU AND..."

I copied and pasted it several times to create an even bigger file, not for the real tests, but for the blog tests.

I didn't use [text] $var to avoid the implicit conversion to System.String, however, if I do that the time improves a lot, but doesn't beat String.Replace. Maybe I should've done it, as you said, to get closer results. (I'm putting a comment in the source code)

Anyway I'm glad to know our results are the same! :) By the way, nice blog! I see you are a PowerShell Master!

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Lox — Thu, 03 Apr 2008 13:32:34 GMT

StringBuilder.Replace returns 'this', not a new instance (like String.Replace). So in this place

$fileContent.Append($str)

for($i = 0; $i -le 200; $i++)

{

$builder = $fileContent.Replace("`n", "")

}

for $i > 0, $fileContent does not contain "'n" - nothing to replace, searching only. IMHO, this fact can affect results.

But.

I've made the same things in C# (.NET 2.0), here is the code:

static void Main(string[] args)

{

const int Runs = 200;

string fileData = null;

string result = null;

using (StreamReader reader = new StreamReader("data.txt", Encoding.GetEncoding(1251)))

{

fileData = reader.ReadToEnd();

}

Stopwatch timer = new Stopwatch();

/* RegEx Replace */

for (int run = 0; run < Runs; run++)

{

timer.Start();

result = Regex.Replace(fileData, "\n", " ");

timer.Stop();

}

Console.WriteLine("Regex.Replace - {0} ms", timer.ElapsedMilliseconds);

timer.Reset();

/* StringBuilder.Replace */

StringBuilder builder = new StringBuilder();

for (int run = 0; run < Runs; run++)

{

builder.Append(fileData);

timer.Start();

builder.Replace("\n", "");

timer.Stop();

builder.Remove(0, builder.Length);

}

Console.WriteLine("StringBuilder.Replace - {0} ms", timer.ElapsedMilliseconds);

timer.Reset();

/* String.Replace */

for (int run = 0; run < Runs; run++)

{

timer.Start();

result = fileData.Replace("\n", "");

timer.Stop();

}

Console.WriteLine("String.Replace - {0} ms", timer.ElapsedMilliseconds);

timer.Reset();

Console.ReadKey();

}

I've got the following results:

Regex.Replace - 3984 ms

StringBuilder.Replace - 1691 ms

String.Replace - 2108 ms

Something's wrong?

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Thu, 03 Apr 2008 21:56:27 GMT

Interesting... your results are different from mine, Joel and http://www.codeproject.com/KB/cs/StringBuilder_vs_String.aspx?fid=326464&df=90&mpp=25&noise=3&sort=Position&view=Quick&fr=26 that uses C#. (I haven't tested your code in my machine)

I'm wonder if someone else has also tested the three approaches in PowerShell or C#/VB.NET. I'm curious to see which approach is the fastest and if there is a consistent winner. :)

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Niki — Fri, 04 Apr 2008 00:41:09 GMT

Did you try replacing longer strings? IIRC Regex uses Boyer-Moore for matching, which should be more efficient for longer patterns. Of course, this only affects the time for searching, not the time needed for replacing the string, so it might also depend on how often the pattern has to be replaced. And since you're using the default locale, the results might be completely different (think factor 10!) on a machine running with a different locale.

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Fri, 04 Apr 2008 09:53:41 GMT

I didn't try to replace longer strings. I haven't investigated the locale, but thanks for pointing it. I'm wondering if the locale should affect the results, not the raw numbers from tests, but which is the fastest approach. My guess (and this is just a wild guess :) ) is that String.Replace should continue to be the fastest approach, because all times would be equally impacted after changing the locale.

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Mark Bussey — Mon, 16 Jun 2008 23:45:39 GMT

Have you run the CLR profiler on these three methods? String objects seem to hang around, clogging up the works, much longer that StringBuilder objects.

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

Roberto Farah — Tue, 17 Jun 2008 00:09:13 GMT

No, I haven't. Did you get different results?

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

William Wegerson — Wed, 05 Aug 2009 21:04:00 GMT

As much as I *love* regex...the situation presented doesn't speak to why one would even think of using regex for that work. Replacing a character is strictly the realm of string/stringbuilder replace and optimized accordingly.

Regex is meant for complicated patterns and has overhead to that end. But the community slams regex due to that overhead. My point is this article as read by the blogsphere, reads that the implication that regex is slow for everything. Factually in this test its slower but there are issues not being considered; hence regex gets painted with a broad stroke.

If one presented a scenario where the replacement need was really a complex situation. I would bet that regex could easily speak to that and provide a good showing. For the *added overhead* of the support or multiple calls needed to use string/stringbuilder replace would begin to slow down and show regex pulling ahead.

Long story short; use the right tool for the right situation. Regex is a truck and used to haul large quantities and string/stringbuilder are sport cars quick but not meant to carry large loads.

Thanks for the article though...it is interesting.

re: Comparing RegEx.Replace, String.Replace and StringBuilder.Replace – Which has better performance?

talav — Thu, 06 Aug 2009 09:34:35 GMT

Regex.Replace - ms1148

StringBuilder.Replace - ms248

String.Replace - ms263

Same results as Lox