Reversing Strings in C#

Reversing a string is a common task in programming, and C# provides several ways to achieve this. In this tutorial, we will explore different methods for reversing strings in C#, including their advantages and disadvantages.

Introduction to String Reversal

String reversal involves rearranging the characters of a string in reverse order. For example, the string "hello" would become "olleh". This operation can be useful in various scenarios, such as data processing, text manipulation, and algorithm implementation.

Method 1: Using Array.Reverse()

One of the most straightforward ways to reverse a string in C# is by using the Array.Reverse() method. Here’s an example:

public static string Reverse(string s)
{
    char[] charArray = s.ToCharArray();
    Array.Reverse(charArray);
    return new string(charArray);
}

This method converts the input string to a character array, reverses the array using Array.Reverse(), and then creates a new string from the reversed array.

Method 2: Using StringBuilder

Another approach is to use a StringBuilder object to reverse the string. Here’s an example:

public static string Reverse(string text)
{
    StringBuilder builder = new StringBuilder(text.Length);
    for (int i = text.Length - 1; i >= 0; i--)
    {
        builder.Append(text[i]);
    }
    return builder.ToString();
}

This method creates a StringBuilder object with the same length as the input string and then appends each character of the input string in reverse order.

Method 3: Using LINQ

If you’re using .NET Framework 3.5 or later, you can use LINQ to reverse a string. Here’s an example:

public static string ReverseString(string srtVarable)
{
    return new string(srtVarable.Reverse().ToArray());
}

This method uses the Reverse() extension method from LINQ to reverse the characters of the input string and then creates a new string from the reversed array.

Handling Unicode Characters

When reversing strings that contain Unicode characters, you need to be careful not to corrupt the data. Here’s an example of how to handle surrogate pairs:

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);
}

This method checks for surrogate pairs and preserves their order when reversing the string.

Performance Comparison

The performance of these methods can vary depending on the length of the input string. Here’s a brief comparison:

• Array.Reverse() is generally the fastest method.
• StringBuilder is slower than Array.Reverse(), but still relatively fast.
• LINQ’s Reverse() method is slower than the other two methods, especially for large input strings.

In conclusion, reversing strings in C# can be achieved using various methods, each with its own advantages and disadvantages. When choosing a method, consider the performance requirements and the type of input data you’re working with.