我刚刚不得不在C# 2.0中编写一个字符串反转函数（即LINQ不可用），并得出了以下结果：
public string Reverse(string text)
{
char[] cArray = text.ToCharArray();
string reverse = String.Empty;
for (int i = cArray.Length - 1; i > -1; i--)
{
reverse += cArray[i];
}
return reverse;
}
就我个人而言，我并不热衷于这个函数，并且确信有更好的方法来完成它。有吗？
public static string Reverse( string s )
{
char[] charArray = s.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
"Les Mise\u0301rables"的解决方案，结果为"selbare\u0301siM seL"。该结果应该像selbarésiM seL一样呈现，而不是像大多数基于代码单元（Array.Reverse等）或甚至代码点（对代理对进行特殊处理的反转）的实现所产生的结果，例如selbaŕesiM seL（请注意重音符号的位置）。using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
public static class Test
{
private static IEnumerable<string> GraphemeClusters(this string s) {
var enumerator = StringInfo.GetTextElementEnumerator(s);
while(enumerator.MoveNext()) {
yield return (string)enumerator.Current;
}
}
private static string ReverseGraphemeClusters(this string s) {
return string.Join("", s.GraphemeClusters().Reverse().ToArray());
}
public static void Main()
{
var s = "Les Mise\u0301rables";
var r = s.ReverseGraphemeClusters();
Console.WriteLine(r);
}
}
（这里还有一个实时运行的示例：https://ideone.com/DqAeMJ）
它简单地使用了 .NET 用于字形簇迭代的 API，这个 API 一直存在，但似乎有点“隐藏”。
这似乎是一个出乎意料的棘手问题。
我建议在大多数情况下使用Array.Reverse，因为它是本地编码的，并且非常简单易懂，易于维护。
根据我测试的所有情况看来，它似乎胜过StringBuilder。
public string Reverse(string text)
{
if (text == null) return null;
// this was posted by petebob as well
char[] array = text.ToCharArray();
Array.Reverse(array);
return new String(array);
}
有第二种方法，对于某些字符串长度可以更快，它使用了 Xor。
public static string ReverseXor(string s)
{
if (s == null) return null;
char[] charArray = s.ToCharArray();
int len = s.Length - 1;
for (int i = 0; i < len; i++, len--)
{
charArray[i] ^= charArray[len];
charArray[len] ^= charArray[i];
charArray[i] ^= charArray[len];
}
return new string(charArray);
}
注意：如果您想支持完整的Unicode UTF16字符集，请阅读此文。并使用那里的实现代替。在字符被反转后，可以通过使用上述算法之一并运行字符串来清理它以进一步优化。
这是StringBuilder、Array.Reverse和Xor方法之间性能比较的结果。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace ConsoleApplication4
{
class Program
{
delegate string StringDelegate(string s);
static void Benchmark(string description, StringDelegate d, int times, string text)
{
Stopwatch sw = new Stopwatch();
sw.Start();
for (int j = 0; j < times; j++)
{
d(text);
}
sw.Stop();
Console.WriteLine("{0} Ticks {1} : called {2} times.", sw.ElapsedTicks, description, times);
}
public static string ReverseXor(string s)
{
char[] charArray = s.ToCharArray();
int len = s.Length - 1;
for (int i = 0; i < len; i++, len--)
{
charArray[i] ^= charArray[len];
charArray[len] ^= charArray[i];
charArray[i] ^= charArray[len];
}
return new string(charArray);
}
public static string ReverseSB(string text)
{
StringBuilder builder = new StringBuilder(text.Length);
for (int i = text.Length - 1; i >= 0; i--)
{
builder.Append(text[i]);
}
return builder.ToString();
}
public static string ReverseArray(string text)
{
char[] array = text.ToCharArray();
Array.Reverse(array);
return (new string(array));
}
public static string StringOfLength(int length)
{
Random random = new Random();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++)
{
sb.Append(Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))));
}
return sb.ToString();
}
static void Main(string[] args)
{
int[] lengths = new int[] {1,10,15,25,50,75,100,1000,100000};
foreach (int l in lengths)
{
int iterations = 10000;
string text = StringOfLength(l);
Benchmark(String.Format("String Builder (Length: {0})", l), ReverseSB, iterations, text);
Benchmark(String.Format("Array.Reverse (Length: {0})", l), ReverseArray, iterations, text);
Benchmark(String.Format("Xor (Length: {0})", l), ReverseXor, iterations, text);
Console.WriteLine();
}
Console.Read();
}
}
}
这是结果：
26251 Ticks String Builder (Length: 1) : called 10000 times.
33373 Ticks Array.Reverse (Length: 1) : called 10000 times.
20162 Ticks Xor (Length: 1) : called 10000 times.
51321 Ticks String Builder (Length: 10) : called 10000 times.
37105 Ticks Array.Reverse (Length: 10) : called 10000 times.
23974 Ticks Xor (Length: 10) : called 10000 times.
66570 Ticks String Builder (Length: 15) : called 10000 times.
26027 Ticks Array.Reverse (Length: 15) : called 10000 times.
24017 Ticks Xor (Length: 15) : called 10000 times.
101609 Ticks String Builder (Length: 25) : called 10000 times.
28472 Ticks Array.Reverse (Length: 25) : called 10000 times.
35355 Ticks Xor (Length: 25) : called 10000 times.
161601 Ticks String Builder (Length: 50) : called 10000 times.
35839 Ticks Array.Reverse (Length: 50) : called 10000 times.
51185 Ticks Xor (Length: 50) : called 10000 times.
230898 Ticks String Builder (Length: 75) : called 10000 times.
40628 Ticks Array.Reverse (Length: 75) : called 10000 times.
78906 Ticks Xor (Length: 75) : called 10000 times.
312017 Ticks String Builder (Length: 100) : called 10000 times.
52225 Ticks Array.Reverse (Length: 100) : called 10000 times.
110195 Ticks Xor (Length: 100) : called 10000 times.
2970691 Ticks String Builder (Length: 1000) : called 10000 times.
292094 Ticks Array.Reverse (Length: 1000) : called 10000 times.
846585 Ticks Xor (Length: 1000) : called 10000 times.
305564115 Ticks String Builder (Length: 100000) : called 10000 times.
74884495 Ticks Array.Reverse (Length: 100000) : called 10000 times.
125409674 Ticks Xor (Length: 100000) : called 10000 times.
好像对于短字符串，异或操作可能更快。
如果您可以使用 LINQ (.NET Framework 3.5+)，那么下面的一行代码将为您提供简短的代码。别忘了添加 using System.Linq; 以便访问Enumerable.Reverse：
public string ReverseString(string srtVarable)
{
return new string(srtVarable.Reverse().ToArray());
}
注意：
如果字符串包含Unicode数据（严格来说是非BMP字符），那么已发布的其他方法会破坏它，因为在反转字符串时无法交换高代理项和低代理项代码单元的顺序。（有关此更多信息，请参见我的博客。）
以下代码示例将正确地反转包含非BMP字符的字符串，例如"\U00010380\U00010381"（乌加里特字母阿尔法，乌加里特字母贝塔）。
public static string Reverse(this string input)
{
if (input == null)
throw new ArgumentNullException("input");
// allocate a buffer to hold the output
char[] output = new char[input.Length];
for (int outputIndex = 0, inputIndex = input.Length - 1; outputIndex < input.Length; outputIndex++, inputIndex--)
{
// check for surrogate pair
if (input[inputIndex] >= 0xDC00 && input[inputIndex] <= 0xDFFF &&
inputIndex > 0 && input[inputIndex - 1] >= 0xD800 && input[inputIndex - 1] <= 0xDBFF)
{
// preserve the order of the surrogate pair code units
output[outputIndex + 1] = input[inputIndex];
output[outputIndex] = input[inputIndex - 1];
outputIndex++;
inputIndex--;
}
else
{
output[outputIndex] = input[inputIndex];
}
}
return new string(output);
}
"悲惨世界"。 - R. Martinho Fernandes好的，为了“不要重复自己”的原则，我提供以下解决方案：
public string Reverse(string text)
{
return Microsoft.VisualBasic.Strings.StrReverse(text);
}
我的理解是，这个实现在VB.NET中默认可用，可以正确处理Unicode字符。
请看维基百科条目这里。他们实现了String.Reverse扩展方法。这使您可以编写如下代码：
string s = "olleh";
s.Reverse();
他们还使用其他答案提到的ToCharArray/Reverse组合。源代码如下：
public static string Reverse(this string input)
{
char[] chars = input.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
从.NET Core 2.1开始，有一种新的方法可以使用string.Create方法来反转字符串。
请注意，此解决方案无法正确处理Unicode组合字符等，例如“Les Mise\u0301rables”会被转换为“selbarésiM seL”。请参见其他答案以获得更好的解决方案。
public static string Reverse(string input)
{
return string.Create<string>(input.Length, input, (chars, state) =>
{
state.AsSpan().CopyTo(chars);
chars.Reverse();
});
}
这实际上是将input的字符复制到一个新字符串中，并在原地反转该新字符串。
string.Create有什么用处？当我们从现有数组创建字符串时，会分配一个新的内部数组并复制值。否则，在创建字符串后（在安全环境中）可能会对其进行变异。也就是说，在以下片段中，我们必须两次分配长度为10的数组，一次作为缓冲区，一次作为字符串的内部数组。
var chars = new char[10];
// set array values
var str = new string(chars);
string.Create实质上允许我们在创建字符串时操作内部数组。也就是说，我们不再需要缓冲区，因此可以避免分配那个char数组。
Steve Gordon在这里详细介绍了它。 MSDN上也有一篇文章（点击链接）。
string.Create？public static string Create<TState>(int length, TState state, SpanAction<char, TState> action);
char数组，第二个参数是您传递给string.Create的数据（状态）。在委托中，我们可以指定如何从数据创建新字符串。在这种情况下，我们只需将输入字符串的字符复制到新字符串使用的Span中。然后，我们反转Span，因此整个字符串被反转。
为了比较我提出的反转字符串的方式与接受的答案，我使用BenchmarkDotNet编写了两个基准测试。
public class StringExtensions
{
public static string ReverseWithArray(string input)
{
var charArray = input.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
public static string ReverseWithStringCreate(string input)
{
return string.Create(input.Length, input, (chars, state) =>
{
state.AsSpan().CopyTo(chars);
chars.Reverse();
});
}
}
[MemoryDiagnoser]
public class StringReverseBenchmarks
{
private string input;
[Params(10, 100, 1000)]
public int InputLength { get; set; }
[GlobalSetup]
public void SetInput()
{
// Creates a random string of the given length
this.input = RandomStringGenerator.GetString(InputLength);
}
[Benchmark(Baseline = true)]
public string WithReverseArray() => StringExtensions.ReverseWithArray(input);
[Benchmark]
public string WithStringCreate() => StringExtensions.ReverseWithStringCreate(input);
}
| Method | InputLength | Mean | Error | StdDev | Gen 0 | Allocated |
| ---------------- | ----------- | -----------: | ---------: | --------: | -----: | --------: |
| WithReverseArray | 10 | 45.464 ns | 0.4836 ns | 0.4524 ns | 0.0610 | 96 B |
| WithStringCreate | 10 | 39.749 ns | 0.3206 ns | 0.2842 ns | 0.0305 | 48 B |
| | | | | | | |
| WithReverseArray | 100 | 175.162 ns | 2.8766 ns | 2.2458 ns | 0.2897 | 456 B |
| WithStringCreate | 100 | 125.284 ns | 2.4657 ns | 2.0590 ns | 0.1473 | 232 B |
| | | | | | | |
| WithReverseArray | 1000 | 1,523.544 ns | 9.8808 ns | 8.7591 ns | 2.5768 | 4056 B |
| WithStringCreate | 1000 | 1,078.957 ns | 10.2948 ns | 9.6298 ns | 1.2894 | 2032 B |
从上面可以看出，使用ReverseWithStringCreate方法只分配了ReverseWithArray方法所用内存的一半。
Greg Beech发布了一个unsafe选项，它确实是最快的（它是一种就地反转）; 但是，正如他在答案中指出的那样，这是一个完全灾难性的想法。
话虽如此，我很惊讶有这么多人一致认为Array.Reverse是最快的方法。仍然有一种unsafe方法可以返回反转后的字符串副本（没有就地反转的花招），对于小字符串来说比Array.Reverse方法快得多：
public static unsafe string Reverse(string text)
{
int len = text.Length;
// Why allocate a char[] array on the heap when you won't use it
// outside of this method? Use the stack.
char* reversed = stackalloc char[len];
// Avoid bounds-checking performance penalties.
fixed (char* str = text)
{
int i = 0;
int j = i + len - 1;
while (i < len)
{
reversed[i++] = str[j--];
}
}
// Need to use this overload for the System.String constructor
// as providing just the char* pointer could result in garbage
// at the end of the string (no guarantee of null terminator).
return new string(reversed, 0, len);
}
你可以看到，随着字符串变得越来越大，性能增益逐渐缩小并最终消失在 Array.Reverse 方法中。但对于小到中等大小的字符串来说，很难超越这种方法。
简单明了的答案是使用扩展方法：
static class ExtentionMethodCollection
{
public static string Inverse(this string @base)
{
return new string(@base.Reverse().ToArray());
}
}
这是输出结果：
string Answer = "12345".Inverse(); // = "54321"
Reverse()和ToArray()的顺序不正确。 - Chris WalshReverse 返回的是 IEnumerable<TSource>，而不是像代码中所示的字符串类型。string Answer = "12345".Inverse(); // = "54321" - Urasquirrel