Есть ли альтернатива string.Replace без учета регистра?

Regex.Replace(strInput, strToken.Replace("$", "[$]"), strReplaceWith, RegexOptions.IgnoreCase);

Метод регулярного выражения должен работать. Однако вы также можете сделать нижний регистр строки из базы данных, нижний регистр -% переменных%, которые у вас есть, а затем найти позиции и длину в строке нижнего регистра из базы данных. Помните, что позиции в строке не меняются только потому, что она записана в нижнем регистре.

Затем, используя цикл, который идет в обратном порядке (это проще, если вы этого не сделаете, вам придется вести текущий счетчик того, куда перемещаются более поздние точки), удалите из вашей строки без нижнего регистра из базы данных% переменных% по их положению и length и вставьте значения замены.

Из MSDN
$ 0 - "Заменяет последнюю подстроку, совпадающую с номером группы (десятичным)."

В .NET регулярных выражениях группа 0 всегда является полным совпадением. Для буквального $ вам нужно

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

Похоже, что у string.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();
}

Кажется, самый простой способ - просто использовать метод Replace, который поставляется с .Net и существует с .Net 1.0:

string res = Microsoft.VisualBasic.Strings.Replace(res, 
                                   "%PolicyAmount%", 
                                   "$0", 
                                   Compare: Microsoft.VisualBasic.CompareMethod.Text);

Чтобы использовать этот метод, вы должны добавить ссылку на сборку Microsoft.VisualBasic. Эта сборка является стандартной частью среды выполнения .Net, она не является дополнительной загрузкой и не помечена как устаревшая.

версия, аналогичная версии C. Dragon, но если вам нужна только одна замена:

int n = myText.IndexOf(oldValue, System.StringComparison.InvariantCultureIgnoreCase);
if (n >= 0)
{
    myText = myText.Substring(0, n)
        + newValue
        + myText.Substring(n + oldValue.Length);
}

Вот способ расширения. Не уверен, где я это нашел.

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

}

    /// <summary>
    /// A case insenstive replace function.
    /// </summary>
    /// <param name = "originalString">The string to examine.(HayStack)</param>
    /// <param name = "oldValue">The value to replace.(Needle)</param>
    /// <param name = "newValue">The new value to be inserted</param>
    /// <returns>A string</returns>
    public static string CaseInsenstiveReplace(string originalString, string oldValue, string newValue)
    {
        Regex regEx = new Regex(oldValue,
           RegexOptions.IgnoreCase | RegexOptions.Multiline);
        return regEx.Replace(originalString, newValue);
    }

Типа запутанная группа ответов, отчасти потому, что заголовок вопроса на самом деле много больше, чем конкретный задаваемый вопрос. Прочитав, я не уверен, что какой-либо ответ - это несколько правок от усвоения всего хорошего здесь, поэтому я решил, что попытаюсь подвести итог.

Вот метод расширения, который, как мне кажется, позволяет избежать упомянутых здесь ошибок и обеспечивает наиболее широко применимое решение.

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
• Этот не пытается пропустить регулярное выражение @Helge (вам действительно нужно делать побайтово, если вы хотите нюхать такую ​​строку вне Regex)
• Проходит отличный тестовый пример @MichaelLiu, "œ".ReplaceCaseInsensitiveFind("oe", ""), хотя, возможно, он имел в виду немного другое поведение.

К сожалению, Комментарий @HA о том, что у вас есть Escape, все три неверны. Начальное значение и newValue не обязательно.

Примечание: Однако вам нужно экранировать $ в новом значении, которое вы вставляете если они являются частью маркера "захваченного значения". Таким образом, три знака доллара в Regex.Replace внутри Regex.Replace [sic]. Без этого что-то вроде этого ломается ...

"This is HIS fork, hIs spoon, hissssssss knife.".ReplaceCaseInsensitiveFind("his", @"he$0r")

Вот ошибка:

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.

Вот что я вам скажу, я знаю, что люди, которые привыкли к Regex, чувствуют, что их использование позволяет избежать ошибок, но я часто все еще неравнодушен к строкам с байтовым сниффингом (но только после прочтения Спольский по кодировкам), чтобы быть абсолютно уверенным, что вы получаете то, для чего рассчитывали. важные варианты использования. Немного напоминает мне Крокфорда из "небезопасные регулярные выражения". Слишком часто мы пишем регулярные выражения, которые позволяют то, что мы хотим (если нам повезет), но непреднамеренно допускаем больше (например, действительно ли $10 является допустимой строкой «значения захвата» в моем регулярном выражении newValue, выше?), Потому что мы не были внимательны. достаточно. Оба метода имеют ценность, и оба поощряют разные типы непреднамеренных ошибок. Сложность часто легко недооценить.

Это странное экранирование $ (и то, что Regex.Escape не избегает шаблонов захваченных значений, таких как $0, как я ожидал в значениях замены) на какое-то время свело меня с ума. Программирование - это сложно (с) 1842

Вот еще один вариант выполнения замен Regex, поскольку не многие люди, кажется, замечают, что совпадения содержат местоположение в строке:

    public static string ReplaceCaseInsensative( this string s, string oldValue, string newValue ) {
        var sb = new StringBuilder(s);
        int offset = oldValue.Length - newValue.Length;
        int matchNo = 0;
        foreach (Match match in Regex.Matches(s, Regex.Escape(oldValue), RegexOptions.IgnoreCase))
        {
            sb.Remove(match.Index - (offset * matchNo), match.Length).Insert(match.Index - (offset * matchNo), newValue);
            matchNo++;
        }
        return sb.ToString();
    }

Вдохновленный ответом cfeduke, я создал эту функцию, которая использует IndexOf для поиска старого значения в строке, а затем заменяет его новым значением. Я использовал это в сценарии SSIS, обрабатывающем миллионы строк, и метод регулярного выражения был намного медленнее этого.

public static string ReplaceCaseInsensitive(this string str, string oldValue, string newValue)
{
    int prevPos = 0;
    string retval = str;
    // find the first occurence of oldValue
    int pos = retval.IndexOf(oldValue, StringComparison.InvariantCultureIgnoreCase);

    while (pos > -1)
    {
        // remove oldValue from the string
        retval = retval.Remove(pos, oldValue.Length);

        // insert newValue in it's place
        retval = retval.Insert(pos, newValue);

        // check if oldValue is found further down
        prevPos = pos + newValue.Length;
        pos = retval.IndexOf(oldValue, prevPos, StringComparison.InvariantCultureIgnoreCase);
    }

    return retval;
}

На основе ответа Джеффа Редди с некоторыми оптимизациями и проверками:

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

    StringBuilder sb = null;

    int startIndex = 0;
    int foundIndex = str.IndexOf(oldValue, comparison);
    while (foundIndex != -1)
    {
        if (sb == null)
            sb = new StringBuilder(str.Length + (newValue != null ? Math.Max(0, 5 * (newValue.Length - oldValue.Length)) : 0));
        sb.Append(str, startIndex, foundIndex - startIndex);
        sb.Append(newValue);

        startIndex = foundIndex + oldValue.Length;
        foundIndex = str.IndexOf(oldValue, startIndex, comparison);
    }

    if (startIndex == 0)
        return str;
    sb.Append(str, startIndex, str.Length - startIndex);
    return sb.ToString();
}

Расширение популярного ответа С. Дракон 76, превратив его код в расширение, которое перегружает метод Replace по умолчанию.

public static class StringExtensions
{
    public static string Replace(this 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();
     }
}

(Поскольку все делают ставку). Вот моя версия (с нулевыми проверками и правильным вводом и экранированием замены) ** Вдохновлена ​​интернетом и другими версиями:

using System;
using System.Text.RegularExpressions;

public static class MyExtensions {
    public static string ReplaceIgnoreCase(this string search, string find, string replace) {
        return Regex.Replace(search ?? "", Regex.Escape(find ?? ""), (replace ?? "").Replace("$", "$$"), RegexOptions.IgnoreCase);          
    }
}

Использование:

var result = "This is a test".ReplaceIgnoreCase("IS", "was");

Позвольте мне изложить свою позицию, и тогда вы можете разорвать меня в клочья, если хотите.

Регулярное выражение не является решением этой проблемы - относительно слишком медленно и требует много памяти.

StringBuilder намного лучше, чем искажение строк.

Поскольку это будет метод расширения для дополнения string.Replace, я считаю важным сопоставить его с тем, как это работает - поэтому важно генерировать исключения для тех же проблем с аргументами, как и возврат исходной строки, если замена не была произведена.

Я считаю, что наличие параметра StringComparison - не лучшая идея. Я попробовал, но тестовый пример, первоначально упомянутый michael-liu, показал проблему: -

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

Хотя IndexOf будет соответствовать, существует несоответствие между длиной совпадения в исходной строке (1) и oldValue.Length (2). Это проявилось в том, что в некоторых других решениях вызывается IndexOutOfRange, когда oldValue.Length был добавлен к текущей позиции совпадения, и я не мог найти способ обойти это. Regex в любом случае не соответствует случаю, поэтому я принял прагматичное решение - использовать только StringComparison.OrdinalIgnoreCase для своего решения.

Мой код похож на другие ответы, но моя особенность заключается в том, что я ищу совпадение, прежде чем приступить к созданию StringBuilder. Если ничего не найдено, можно избежать потенциально большого выделения. Затем код становится do{...}while, а не 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();
    }

Начиная с .NET Core 2.0 или .NET Standard 2.1 соответственно, это встроено в среду выполнения .NET [1]:

"hello world".Replace("World", "csharp", StringComparison.CurrentCultureIgnoreCase); // "hello csharp"

[1] https://docs.microsoft.com/en-us/dotnet/api/system.string.replace#System_String_Replace_System_String_System_String_System_StringComparison_