首先，你必须理解的是str+=将调整字符串内存大小，为1个额外的字符腾出空间。这很好，但是如果你有一本1000页的书，你想要反转，这将需要很长时间来执行。

有些人建议的解决方案是使用StringBuilder。字符串构建器在执行+=时所做的是分配更大的内存块来保存新字符，这样它就不需要在每次添加字符时进行重新分配。

如果你真的想要一个快速和最小的解决方案，我建议如下:

            char[] chars = new char[str.Length];
            for (int i = str.Length - 1, j = 0; i >= 0; --i, ++j)
            {
                chars[j] = str[i];
            }
            str = new String(chars);

在这个解决方案中，在初始化char[]时有一个初始内存分配，在string构造函数从char数组构建字符串时有一个初始内存分配。

在我的系统上，我为您运行了一个测试，反转了一个2750,000个字符的字符串。以下是10次执行的结果:

StringBuilder: 190K - 200K tick

字符数组:130K - 160K

我还运行了一个正常String +=的测试，但我在10分钟后放弃了它，没有输出。

但是，我也注意到，对于较小的字符串，StringBuilder更快，因此您必须根据输入来决定实现。

干杯

选择倒档(“somestring”); 完成了。

Greg Beech发布了一个不安全的选项，它确实很快(这是一个原地逆转);但是，正如他在回答中指出的那样，这完全是一个灾难性的想法。

也就是说，我很惊讶有这么多的共识，Array。逆向是最快的方法。仍然有一种不安全的方法，它返回字符串的反向副本(没有原地反转的恶作剧)，比Array快得多。小字符串的反向方法:

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，性能增益会缩小，然后消失。当字符串变大时，反向方法。然而，对于小型到中型的字符串，很难击败这种方法。

首先，你不需要调用ToCharArray，因为字符串已经可以被索引为char数组，所以这将节省你的分配。

下一个优化是使用StringBuilder来防止不必要的分配(因为字符串是不可变的，连接它们每次都会复制一个字符串)。为了进一步优化这一点，我们预先设置了StringBuilder的长度，这样它就不需要扩展它的缓冲区。

public string Reverse(string text)
{
    if (string.IsNullOrEmpty(text))
    {
        return text;
    }

    StringBuilder builder = new StringBuilder(text.Length);
    for (int i = text.Length - 1; i >= 0; i--)
    {
        builder.Append(text[i]);
    }

    return builder.ToString();
}

编辑:性能数据

我使用Array测试了这个函数和这个函数。用下面的简单程序进行反向，其中Reverse1是一个函数，Reverse2是另一个函数:

static void Main(string[] args)
{
    var text = "abcdefghijklmnopqrstuvwxyz";

    // pre-jit
    text = Reverse1(text); 
    text = Reverse2(text);

    // test
    var timer1 = Stopwatch.StartNew();
    for (var i = 0; i < 10000000; i++)
    {
        text = Reverse1(text);
    }

    timer1.Stop();
    Console.WriteLine("First: {0}", timer1.ElapsedMilliseconds);

    var timer2 = Stopwatch.StartNew();
    for (var i = 0; i < 10000000; i++)
    {
        text = Reverse2(text);
    }

    timer2.Stop();
    Console.WriteLine("Second: {0}", timer2.ElapsedMilliseconds);

    Console.ReadLine();
}

事实证明，对于短字符串数组。反向方法大约是上面方法的两倍，对于更长的字符串，差异甚至更明显。已知这个数组。反向法既简单又快，我建议你用那个而不是这个。我把这个留在这里只是为了表明这不是你应该做的方式(让我很惊讶!)

我在面试中也被问到类似的问题。这是我的回答，尽管它在性能上可能没有其他答案那么快。我的问题是“创建一个类，它可以有一个反向打印字符串的方法”:

using System;
using System.Collections.Generic;
using System.Linq;

namespace BackwardsTest
{
    class PrintBackwards
    {
        public static void print(string param)
        {
            if (param == null || param.Length == 0)
            {
                Console.WriteLine("string is null");
                return;
            }
            List<char> list = new List<char>();
            string returned = null;
            foreach(char d in param)
            {
                list.Add(d);
            }
            for(int i = list.Count(); i > 0; i--)
            {
                returned = returned + list[list.Count - 1];
                list.RemoveAt(list.Count - 1);
            }
            Console.WriteLine(returned);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            string test = "I want to print backwards";
            PrintBackwards.print(test);
            System.Threading.Thread.Sleep(5000);
        }
    }
}

下面是该函数的unicode安全版本，编写为将安全处理unicode的扩展。它接近标记的完整答案，但不会抛出“无效的高代理字符”异常。

public static class StringExtensions
{
    public static string Reverse(this string s)
    {
        var info = new StringInfo(s);
        var charArray = new char[s.Length];
        var teIndices = StringInfo.ParseCombiningCharacters(s).Reverse();

        int j = 0;
        foreach(var i in  teIndices)
        {
            if (char.IsHighSurrogate(s[i]))
            {
                charArray[j] = s[i];
                j++;
                charArray[j] = s[i+1];
            }
            else
            {
                charArray[j] = s[i];
            }
            j++;
        }

        return new string(charArray);

    }
}