Coder Perfect

String.Replace ignoring case


“Hello world” is a string I created.

I’ll need to change “world” to “csharp.”

This is what I use:

string.Replace("World", "csharp");

However, as a result, the string is not replaced. The reason for this is case sensitivity. The original string contains the word “world,” which I’m attempting to change.

Is there any way to circumvent string’s case sensitivity? Is it possible to replace the method?

Asked by Sandeep

Solution #1

You might conduct a case-insensitive replace using a Regex:

class Program
    static void Main()
        string input = "hello WoRlD";
        string result = 
           Regex.Replace(input, "world", "csharp", RegexOptions.IgnoreCase);
        Console.WriteLine(result); // prints "hello csharp"

Answered by Darin Dimitrov

Solution #2

var search = "world";
var replacement = "csharp";
string result = Regex.Replace(

If you rely on user input that incorporates Regex language elements, the Regex.Escape function is useful.


You don’t have to escape the replacement string thanks to comments.

Here’s a little jig to see how well the code works:

using System;
using System.Text.RegularExpressions;           
public class Program
    public static void Main()

        var tests = new[] {
            new { Input="abcdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
            new { Input="ABCdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
            new { Input="A*BCdef", Search="a*bc", Replacement="xyz", Expected="xyzdef" },
            new { Input="abcdef", Search="abc", Replacement="x*yz", Expected="x*yzdef" },       
            new { Input="abcdef", Search="abc", Replacement="$", Expected="$def" },

        foreach(var test in tests){
            var result = ReplaceCaseInsensitive(test.Input, test.Search, test.Replacement);

                "Success: {0}, Actual: {1}, {2}",
                result == test.Expected,



    private static string ReplaceCaseInsensitive(string input, string search, string replacement){
        string result = Regex.Replace(
        return result;

Its output is:

Success: True, Actual: xyzdef, { Input = abcdef, Search = abc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: xyzdef, { Input = ABCdef, Search = abc, Replacement = xyz, Expected = xyzdef }
Success: True, Actual: xyzdef, { Input = A*BCdef, Search = a*bc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: x*yzdef, { Input = abcdef, Search = abc, Replacement = x*yz, Expected = x*yzdef} 
Success: True, Actual: $def, { Input = abcdef, Search = abc, Replacement = $, Expected = $def }

Answered by Steve B

Solution #3

This approach is 2.5X FASTER and MORE EFFECTIVE than previous regular expressions methods:

/// <summary>
/// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another 
/// specified string according the type of search to use for the specified string.
/// </summary>
/// <param name="str">The string performing the replace method.</param>
/// <param name="oldValue">The string to be replaced.</param>
/// <param name="newValue">The string replace all occurrences of <paramref name="oldValue"/>. 
/// If value is equal to <c>null</c>, than all occurrences of <paramref name="oldValue"/> will be removed from the <paramref name="str"/>.</param>
/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
/// <returns>A string that is equivalent to the current string except that all instances of <paramref name="oldValue"/> are replaced with <paramref name="newValue"/>. 
/// If <paramref name="oldValue"/> is not found in the current instance, the method returns the current instance unchanged.</returns>
public static string Replace(this string str,
    string oldValue, string @newValue,
    StringComparison comparisonType)

    // Check inputs.
    if (str == null)
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentNullException(nameof(str));
    if (str.Length == 0)
        // Same as original .NET C# string.Replace behavior.
        return str;
    if (oldValue == null)
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentNullException(nameof(oldValue));
    if (oldValue.Length == 0)
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentException("String cannot be of zero length.");

    //if (oldValue.Equals(newValue, comparisonType))
    //This condition has no sense
    //It will prevent method from replacesing: "Example", "ExAmPlE", "EXAMPLE" to "example"
    //return str;

    // Prepare string builder for storing the processed string.
    // Note: StringBuilder has a better performance than String by 30-40%.
    StringBuilder resultStringBuilder = new StringBuilder(str.Length);

    // Analyze the replacement: replace or remove.
    bool isReplacementNullOrEmpty = string.IsNullOrEmpty(@newValue);

    // Replace all values.
    const int valueNotFound = -1;
    int foundAt;
    int startSearchFromIndex = 0;
    while ((foundAt = str.IndexOf(oldValue, startSearchFromIndex, comparisonType)) != valueNotFound)

        // Append all characters until the found replacement.
        int @charsUntilReplacment = foundAt - startSearchFromIndex;
        bool isNothingToAppend = @charsUntilReplacment == 0;
        if (!isNothingToAppend)
            resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilReplacment);

        // Process the replacement.
        if (!isReplacementNullOrEmpty)

        // Prepare start index for the next search.
        // This needed to prevent infinite loop, otherwise method always start search 
        // from the start of the string. For example: if an oldValue == "EXAMPLE", newValue == "example"
        // and comparisonType == "any ignore case" will conquer to replacing:
        // "EXAMPLE" to "example" to "example" to "example" … infinite loop.
        startSearchFromIndex = foundAt + oldValue.Length;
        if (startSearchFromIndex == str.Length)
            // It is end of the input string: no more space for the next search.
            // The input string ends with a value that has already been replaced. 
            // Therefore, the string builder with the result is complete and no further action is required.
            return resultStringBuilder.ToString();

    // Append the last part to the result.
    int @charsUntilStringEnd = str.Length - startSearchFromIndex;
    resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilStringEnd);

    return resultStringBuilder.ToString();


Note that case == StringComparison is ignored. OrdinalIgnoreCase is a comparisonType parameter for StringComparison. It’s the quickest and most case-insensitive method of replacing all values.

The following are some of the advantages of this method:

Benchmark-proof: this method is 2.59X quicker than @Steve B.’s regex, code:

// Results:
// 1/2. Regular expression solution: 4486 milliseconds
// 2/2. Current solution: 1727 milliseconds — 2.59X times FASTER! than regex!

// Notes: the test was started 5 times, the result is an average; release build.

const int benchmarkIterations = 1000000;
const string sourceString = "aaaaddsdsdsdsdsd";
const string oldValue = "D";
const string newValue = "Fod";
long totalLenght = 0;

Stopwatch regexStopwatch = Stopwatch.StartNew();
string tempString1;
for (int i = 0; i < benchmarkIterations; i++)
    tempString1 = sourceString;
    tempString1 = ReplaceCaseInsensitive(tempString1, oldValue, newValue);

    totalLenght = totalLenght + tempString1.Length;

Stopwatch currentSolutionStopwatch = Stopwatch.StartNew();
string tempString2;
for (int i = 0; i < benchmarkIterations; i++)
    tempString2 = sourceString;
    tempString2 = tempString2.Replace(oldValue, newValue,

    totalLenght = totalLenght + tempString2.Length;

@Darky711 had the original idea, and @MinerR provided StringBuilder.

Answered by Oleg Zarevennyi

Solution #4

Regex is used in a lot of the recommendations. How about this way of extension without it:

public static string Replace(this string str, string old, string @new, StringComparison comparison)
    @new = @new ?? "";
    if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(old) || old.Equals(@new, comparison))
        return str;
    int foundAt = 0;
    while ((foundAt = str.IndexOf(old, foundAt, comparison)) != -1)
        str = str.Remove(foundAt, old.Length).Insert(foundAt, @new);
        foundAt += @new.Length;
    return str;

Answered by Oleg Fridman

Solution #5

Extensions make our lives easier in the following ways:

static public class StringExtensions
    static public string ReplaceInsensitive(this string str, string from, string to)
        str = Regex.Replace(str, from, to, RegexOptions.IgnoreCase);
        return str;

Answered by Petrucio

Post is based on