Cross-posted from SQLBlog! -
http://www.sqlblog.com
Over in the Simple-Talk forums, there is
a good thread going about how best to reverse a string in .NET, since no string reverse method is included in the BCL.
A
few suggestions were made, and someone implied that they were too
complex and that simplicity is the most important factor. Personally,
I wonder -- does complexity really matter in this case? I would expect
that you'd
program this kind of thing exactly once, put it into a utility class
somewhere, and
never worry about the implementation again. Given that assumption, it
becomes more of a performance question for me.
To that end, I've run a few tests. I created three methods -- the
first is a method using StringBuilder, as suggested by one of the
respondants in the thread who felt it was the simplest method of
achieving tho goal. The second uses Array.Reverse, and is perhaps
slightly more obscure. The third method is a modification of the
first, in which the main loop iterates over an array of chars instead
of the string, which I had a
hunch would be faster (alas, tests show that I was not correct in my
assumption). Following
are the methods:
public static string Reverse1(string s)
{
StringBuilder sb = new System.Text.StringBuilder(s.Length);
int i = s.Length;
while (i-- > 0)
{
sb.Append(s[i]);
}
return sb.ToString();
}
public static string Reverse2(string s)
{
char[] rev = s.ToCharArray();
Array.Reverse(rev);
return (new string(rev));
}
public static string Reverse3(string s)
{
char[] charArray = s.ToCharArray();
int i = charArray.Length;
StringBuilder sb = new System.Text.StringBuilder(i);
while (i-- > 0)
{
sb.Append(s[i]);
}
return sb.ToString();
}
I turned on Visual Studio's profiler to collect timings and ran these
methods in a loop. First test was reversing 26 characters (a-z), which
I ran in a loop 10,000 times for each method. Results:
Reverse1: 506.775 ms
Reverse2: 58.327 ms
Reverse3: 522.484 ms
The second test was reversing 2080 characters (a-z repeated 80 times).
I was only able to run this test in the loop 2500 times, as my
workstation is currently very low on disk space and the VS profiler's
output takes up a lot of room. Results:
Reverse1: 2060.424 ms
Reverse2: 117.874 ms
Reverse3: 2368.861 ms
Results are total time spent in each function and its children over the course of all iterations.
So for me, the Array.Reverse method is what I would use... Anyone out there have a better version to share?