C# 在不使用Reverse的情况下反转字符串。这是可行的，但为什么呢？

好的，我的一个朋友让我帮助他使用一种字符串反转方法，这种方法可以在不使用string.reverse的情况下重用（这是他的家庭作业）。现在，我做到了，下面是代码。它起作用了。事实上非常棒。显然，通过查看它，您可以看到字符串越大，工作时间越长。然而，我的问题是，为什么它会起作用？编程需要大量的尝试和错误，我更多的是伪编码，而不是实际编码，而且效果很好

有人能给我解释一下反向=ch+反向的确切方式吗；他在工作吗？我不明白是什么让它反转：/

class Program
{

    static void Reverse(string x)
    {

        string text = x;
        string reverse = string.Empty;
        foreach (char ch in text)
        {

            reverse = ch + reverse;
            // this shows the building of the new string. 
            // Console.WriteLine(reverse);
        }

        Console.WriteLine(reverse);        

    }
    static void Main(string[] args)
    {

        string comingin;
        Console.WriteLine("Write something");
        comingin = Console.ReadLine();
       Reverse(comingin);

        // pause
        Console.ReadLine();
    }



}

---

如果传递的字符串为“hello”，则循环将执行以下操作：

reverse

='h'+

string.Empty

反向

='e'+'h'

反向

='l'+'eh'

直到它等于

---

olleh

如果传递的字符串是“hello”，则循环将执行以下操作：

reverse

='h'+

string.Empty

反向

='e'+'h'

反向

='l'+'eh'

直到它等于

---

olleh

如果您的字符串是

My string

，则：

Pass 1, reverse = 'M'
Pass 2, reverse = 'yM'
Pass 3, reverse = ' yM'

---

你拿着每个字符，说“那个字符，在它后面加上我之前的字符”。

如果你的字符串是

我的字符串，那么：

Pass 1, reverse = 'M'
Pass 2, reverse = 'yM'
Pass 3, reverse = ' yM'

你拿着每个字符，说“那个字符，在它后面加上我之前的字符”。
请想象你的输入字符串是“abc”。之后，您可以看到字母被逐个提取并添加到新字符串的开头：

反向=”，ch='a'=>反向（ch+反向）=“a”
反向=a“，ch='b'==>反向（ch+反向）=b+a=“ba”
反向=“ba”，ch='c'==>反向（ch+反向）=c+ba=“cba”
请设想您的入口字符串是“abc”。之后，您可以看到字母被逐个提取并添加到新字符串的开头：

反向=”，ch='a'=>反向（ch+反向）=“a”
反向=a“，ch='b'==>反向（ch+反向）=b+a=“ba”
反向=“ba”，ch='c'==>反向（ch+反向）=c+ba=“cba”
我想你的问题已经回答了。我的答覆超越了眼前的问题，更关乎这项工作的精神。我记得几十年前在大学里做过这个任务，当时内存和大型机（yikes！）的处理时间非常宝贵。我们的任务是反转数组或字符串，这是一个字符数组，而不创建第二个数组或字符串。这项活动的精神是教导人们要注意现有的资源

在.NET中，字符串是不可变的对象，所以我必须使用第二个字符串。我又写了3个例子来演示不同的技术，这些技术可能比您的方法更快，但不应该用来取代内置的.NET替换方法。我偏爱最后一个

    // StringBuilder inserting at 0 index
    public static string Reverse2(string inputString)
    {
        var result = new StringBuilder();
        foreach (char ch in inputString)
        {
            result.Insert(0, ch);
        }
        return result.ToString();
    }

    // Process inputString backwards and append with StringBuilder
    public static string Reverse3(string inputString)
    {
        var result = new StringBuilder();
        for (int i = inputString.Length - 1; i >= 0; i--)
        {
            result.Append(inputString[i]);
        }
        return result.ToString();
    }

    // Convert string to array and swap pertinent items
    public static string Reverse4(string inputString)
    {
        var chars = inputString.ToCharArray();
        for (int i = 0; i < (chars.Length/2); i++)
        {
            var temp = chars[i];
            chars[i] = chars[chars.Length - 1 - i];
            chars[chars.Length - 1 - i] = temp;
        }
        return new string(chars);
    }

//在0索引处插入StringBuilder
公共静态字符串反转2（字符串输入字符串）
{
var result=新的StringBuilder（）；
foreach（输入字符串中的字符）
{
结果：插入（0，ch）；
}
返回result.ToString（）；
}
//向后处理inputString并使用StringBuilder追加
公共静态字符串反转3（字符串输入字符串）
{
var result=新的StringBuilder（）；
对于（inti=inputString.Length-1；i>=0；i--）
{
result.Append（inputString[i]）；
}
返回result.ToString（）；
}
//将字符串转换为数组并交换相关项
公共静态字符串反转4（字符串输入字符串）
{
var chars=inputString.ToCharArray（）；
对于（int i=0；i<（字符长度/2）；i++）
{
var temp=字符[i]；
字符[i]=字符[chars.Length-1-i]；
字符[字符长度-1-i]=温度；
}
返回新字符串（字符）；
}
我想你的问题已经得到了回答。我的答覆超越了眼前的问题，更关乎这项工作的精神。我记得几十年前在大学里做过这个任务，当时内存和大型机（yikes！）的处理时间非常宝贵。我们的任务是反转数组或字符串，这是一个字符数组，而不创建第二个数组或字符串。这项活动的精神是教导人们要注意现有的资源

在.NET中，字符串是不可变的对象，所以我必须使用第二个字符串。我又写了3个例子来演示不同的技术，这些技术可能比您的方法更快，但不应该用来取代内置的.NET替换方法。我偏爱最后一个

    // StringBuilder inserting at 0 index
    public static string Reverse2(string inputString)
    {
        var result = new StringBuilder();
        foreach (char ch in inputString)
        {
            result.Insert(0, ch);
        }
        return result.ToString();
    }

    // Process inputString backwards and append with StringBuilder
    public static string Reverse3(string inputString)
    {
        var result = new StringBuilder();
        for (int i = inputString.Length - 1; i >= 0; i--)
        {
            result.Append(inputString[i]);
        }
        return result.ToString();
    }

    // Convert string to array and swap pertinent items
    public static string Reverse4(string inputString)
    {
        var chars = inputString.ToCharArray();
        for (int i = 0; i < (chars.Length/2); i++)
        {
            var temp = chars[i];
            chars[i] = chars[chars.Length - 1 - i];
            chars[chars.Length - 1 - i] = temp;
        }
        return new string(chars);
    }

//在0索引处插入StringBuilder
公共静态字符串反转2（字符串输入字符串）
{
var result=新的StringBuilder（）；
foreach（输入字符串中的字符）
{
结果：插入（0，ch）；
}
返回result.ToString（）；
}
//向后处理inputString并使用StringBuilder追加
公共静态字符串反转3（字符串输入字符串）
{
var result=新的StringBuilder（）；
对于（inti=inputString.Length-1；i>=0；i--）
{
result.Append（inputString[i]）；
}
返回result.ToString（）；
}
//将字符串转换为数组并交换相关项
公共静态字符串反转4（字符串输入字符串）
{
var chars=inputString.ToCharArray（）；
对于（int i=0；i<（字符长度/2）；i++）
{
var temp=字符[i]；
字符[i]=字符[chars.Length-1-i]；
字符[字符长度-1-i]=温度；
}
返回新字符串（字符）；
}
为了测试Romoku关于使用
StringBuilder的建议，我编写了以下代码

   public static void Reverse(string x)
        {
            string text = x;
            string reverse = string.Empty;
            foreach (char ch in text)
            {
                reverse = ch + reverse;
            }
            Console.WriteLine(reverse);
        }

        public static void ReverseFast(string x)
        {
            string text = x;
            StringBuilder reverse = new StringBuilder();
            for (int i = text.Length - 1; i >= 0; i--)
            {
                reverse.Append(text[i]);
            }             
            Console.WriteLine(reverse);
        }

        public static void Main(string[] args)
        {
            int abcx = 100; // amount of abc's
            string abc = ""; 
            for (int i = 0; i < abcx; i++)
                abc += "abcdefghijklmnopqrstuvwxyz";
            var x = new System.Diagnostics.Stopwatch();
            x.Start();
            Reverse(abc);
            x.Stop();
            string ReverseMethod = "Reverse Method: " + x.ElapsedMilliseconds.ToString();
            x.Restart();
            ReverseFast(abc);
            x.Stop();
            Console.Clear();
            Console.WriteLine("Method | Milliseconds");
            Console.WriteLine(ReverseMethod);
            Console.WriteLine("ReverseFast Method: " + x.ElapsedMilliseconds.ToString());
            System.Console.Read();
        }

公共静态无效反向（字符串x）
{
字符串文本=x；
string reverse=string.Empty；