看起来像绳子。Replace应该有一个重载，接受StringComparison参数。因为它没有，你可以尝试这样做:

public static string ReplaceString(string str, string oldValue, string newValue, StringComparison comparison)
{
    StringBuilder sb = new StringBuilder();

    int previousIndex = 0;
    int index = str.IndexOf(oldValue, comparison);
    while (index != -1)
    {
        sb.Append(str.Substring(previousIndex, index - previousIndex));
        sb.Append(newValue);
        index += oldValue.Length;

        previousIndex = index;
        index = str.IndexOf(oldValue, index, comparison);
    }
    sb.Append(str.Substring(previousIndex));

    return sb.ToString();
}

这是一个扩展方法。不知道在哪里找到的。

public static class StringExtensions
{
    public static string Replace(this string originalString, string oldValue, string newValue, StringComparison comparisonType)
    {
        int startIndex = 0;
        while (true)
        {
            startIndex = originalString.IndexOf(oldValue, startIndex, comparisonType);
            if (startIndex == -1)
                break;

            originalString = originalString.Substring(0, startIndex) + newValue + originalString.Substring(startIndex + oldValue.Length);

            startIndex += newValue.Length;
        }

        return originalString;
    }

}

先让我解释清楚，然后你可以把我撕成碎片。

Regex并不是这个问题的答案——相对来说，它太慢，内存太大。

StringBuilder比string mangling好得多。

因为这将是一个补充字符串的扩展方法。Replace，我认为匹配它的工作方式很重要——因此，对于相同的参数问题抛出异常非常重要，因为如果没有进行替换，则返回原始字符串。

我认为使用StringComparison参数不是一个好主意。 我确实尝试过，但michael-liu最初提到的测试用例显示了一个问题:-

[TestCase("œ", "oe", "", StringComparison.InvariantCultureIgnoreCase, Result = "")]

虽然IndexOf会匹配，但源字符串(1)和oldValue的匹配长度不匹配。长度(2).这通过在一些其他解决方案中导致IndexOutOfRange来体现。长度被添加到当前的匹配位置，我找不到绕过这个方法。 Regex无论如何都无法匹配这种情况，所以我采取了只使用StringComparison的实用解决方案。OrdinalIgnoreCase为我的解决方案。

我的代码类似于其他答案，但我的扭曲是，我在创建StringBuilder之前寻找匹配。如果没有发现，则避免潜在的大分配。然后代码就变成了do{…}while而不是a while{…}

我已经针对其他答案做了一些广泛的测试，这个答案的速度略快，使用的内存也略少。

    public static string ReplaceCaseInsensitive(this string str, string oldValue, string newValue)
    {
        if (str == null) throw new ArgumentNullException(nameof(str));
        if (oldValue == null) throw new ArgumentNullException(nameof(oldValue));
        if (oldValue.Length == 0) throw new ArgumentException("String cannot be of zero length.", nameof(oldValue));

        var position = str.IndexOf(oldValue, 0, StringComparison.OrdinalIgnoreCase);
        if (position == -1) return str;

        var sb = new StringBuilder(str.Length);

        var lastPosition = 0;

        do
        {
            sb.Append(str, lastPosition, position - lastPosition);

            sb.Append(newValue);

        } while ((position = str.IndexOf(oldValue, lastPosition = position + oldValue.Length, StringComparison.OrdinalIgnoreCase)) != -1);

        sb.Append(str, lastPosition, str.Length - lastPosition);

        return sb.ToString();
    }

这是一组令人困惑的答案，部分原因是问题的标题实际上比被问到的具体问题要大得多。在读完之后，我不确定是否有任何答案与吸收这里所有的好东西有几次编辑之差，所以我想我应该试着总结一下。

下面是一种扩展方法，我认为它避免了这里提到的陷阱，并提供了最广泛适用的解决方案。

public static string ReplaceCaseInsensitiveFind(this string str, string findMe,
    string newValue)
{
    return Regex.Replace(str,
        Regex.Escape(findMe),
        Regex.Replace(newValue, "\\$[0-9]+", @"$$$0"),
        RegexOptions.IgnoreCase);
}

所以…

这是一个扩展方法@MarkRobinson 这并没有尝试跳过Regex @Helge(如果你想在Regex之外像这样的字符串嗅探，你真的必须一个字节一个字节地做) 通过了@MichaelLiu的优秀测试案例“”。ReplaceCaseInsensitiveFind(“oe”，“”)，尽管他可能有一个稍微不同的行为。

不幸的是，@HA的评论，你必须逃避所有三个是不正确的。初始值和newValue不需要是。

注意:但是，如果$s是“捕获值”标记的一部分，则必须在插入的新值中转义$s。因此正则表达式中有三个美元符号。在正则表达式中替换。取代(原文如此)。没有它，像这样的东西就会碎…

“这是他的叉子，他的勺子，他的刀。”ReplaceCaseInsensitiveFind(“他”@”他$ 0 r”)

错误如下:

An unhandled exception of type 'System.ArgumentException' occurred in System.dll

Additional information: parsing "The\hisr\ is\ he\HISr\ fork,\ he\hIsr\ spoon,\ he\hisrsssssss\ knife\." - Unrecognized escape sequence \h.

Tell you what, I know folks that are comfortable with Regex feel like their use avoids errors, but I'm often still partial to byte sniffing strings (but only after having read Spolsky on encodings) to be absolutely sure you're getting what you intended for important use cases. Reminds me of Crockford on "insecure regular expressions" a little. Too often we write regexps that allow what we want (if we're lucky), but unintentionally allow more in (eg, Is $10 really a valid "capture value" string in my newValue regexp, above?) because we weren't thoughtful enough. Both methods have value, and both encourage different types of unintentional errors. It's often easy to underestimate complexity.

奇怪的$转义(和正则表达式。Escape没有逃脱捕获的价值模式，如我所期望的替换值为0)，这让我抓狂了一段时间。编程难(c) 1842年

从MSDN $0 - "替换组号number(十进制)匹配的最后一个子字符串。"

在。net正则表达式中，0组总是整个匹配。对于字面上的$，你需要

string value = Regex.Replace("%PolicyAmount%", "%PolicyAmount%", @"$$0", RegexOptions.IgnoreCase);

正则表达式方法应该可以工作。但是，您还可以将数据库中的字符串小写，将您拥有的%variables%小写，然后从数据库中定位小写字符串中的位置和长度。记住，字符串中的位置不会因为小写而改变。

然后使用一个反向循环(它更容易，如果你不这样做，你将不得不保持一个运行的计数，后来的点移动到哪里)从你的非小写字符串从数据库中删除%变量%的位置和长度，并插入替换值。