Czy istnieje alternatywa dla string.Replace, która nie rozróżnia wielkości liter?

Muszę poszukać ciąg i zastąpić wszystkie wystąpienia %FirstName%i %PolicyAmount%o wartości pobierane z bazy danych. Problem polega na tym, że wielkość liter w FirstName jest różna. To uniemożliwia mi użycie tej String.Replace()metody. Widziałem strony internetowe na ten temat, które sugerują

Regex.Replace(strInput, strToken, strReplaceWith, RegexOptions.IgnoreCase);

Jednak z jakiegoś powodu, gdy próbuję i zastąpić %PolicyAmount%ze $0nigdy wymiana odbywa. Zakładam, że ma to coś wspólnego ze znakiem dolara będącym zarezerwowaną postacią w wyrażeniu regularnym.

Czy mogę zastosować inną metodę, która nie wymaga dezynfekcji danych wejściowych w celu radzenia sobie ze znakami specjalnymi wyrażeń regularnych?

Od MSDN
0 USD - „Zastępuje ostatni podciąg zgodny z numerem grupy (dziesiętnym)”.

W .NET Wyrażenia regularne grupa 0 jest zawsze całym dopasowaniem. Aby uzyskać dosłowny $ musisz

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

Wydaje się, że string.Replace powinien mieć przeciążenie, które wymaga StringComparisonargumentu. Ponieważ tak nie jest, możesz spróbować czegoś takiego:

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

Rodzaj mylącej grupy odpowiedzi, po części dlatego, że tytuł pytania jest w rzeczywistości znacznie większy niż zadawane pytanie szczegółowe. Po przeczytaniu nie jestem pewien, czy odpowiedź jest kilka zmian od przyswojenia wszystkich dobrych rzeczy tutaj, więc pomyślałem, że spróbuję podsumować.

Oto metoda rozszerzenia, która moim zdaniem pozwala uniknąć wspomnianych tutaj pułapek i zapewnia najszerzej stosowane rozwiązanie.

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

Więc...

• Jest to metoda rozszerzenia @ MarkRobinson
• To nie spróbować pominąć Regex @Helge (naprawdę trzeba zrobić bajt po bajcie, jeśli chcesz strun nosem jak ten zewnątrz Regex)
• Przechodzi @MichaelLiu „s doskonałą przypadek testowy , "œ".ReplaceCaseInsensitiveFind("oe", "")choć może on mieć nieco inne zachowanie w umyśle.

Niestety, komentarz @HA, który masz do Escapewszystkich trzech, jest niepoprawny . Wartość początkowa i newValuenie musi być.

Uwaga: Musisz jednak uciec $s w nowej wartości, którą wstawiasz, jeśli są częścią czegoś, co wydaje się być znacznikiem „przechwyconej wartości” . Zatem trzy znaki dolara w Regex.Replace wewnątrz Regex.Replace [sic]. Bez tego coś takiego się psuje ...

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

Oto błąd:

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.

Powiem ci co, wiem, że ludzie, którzy czują się komfortowo z Regex, czują, że ich użycie pozwala uniknąć błędów, ale często wciąż jestem stronniczy w bajtowaniu ciągów wąchania (ale dopiero po przeczytaniu Spolskyego na temat kodowania ), aby mieć absolutną pewność, że otrzymujesz to, co masz przeznaczony do ważnych zastosowań. Trochę przypomina mi Crockforda o „ niepewnych wyrażeniach regularnych ”. Zbyt często piszemy wyrażenia regularne, które pozwalają na to, czego chcemy (jeśli mamy szczęście), ale przypadkowo dopuszczają więcej (np. Czy $10naprawdę jest prawidłowym ciągiem „wartość przechwytywania” w moim nowym wyrażeniu regularnym powyżej?), Ponieważ nie byliśmy wystarczająco rozważni . Obie metody mają wartość i obie zachęcają do różnego rodzaju niezamierzonych błędów. Często łatwo jest nie docenić złożoności.

Ta dziwna $ucieczka (i która Regex.Escapenie uciekła z przechwyconych wzorców wartości, tak $0jak bym się spodziewał po wartościach zastępczych) doprowadziła mnie na chwilę do szaleństwa. Programowanie jest trudne (c) 1842

Oto metoda rozszerzenia. Nie jestem pewien, gdzie to znalazłem.

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

}

Wydaje się, że najłatwiejszą metodą jest po prostu użycie metody Zamień, która jest dostarczana z .Net i jest dostępna od .Net 1.0:

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

Aby użyć tej metody, musisz dodać odwołanie do zestawu Microsoft.VisualBasic. Ten zestaw jest standardową częścią środowiska wykonawczego .Net, nie jest dodatkowym plikiem do pobrania ani oznaczony jako przestarzały.

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

Zainspirowany odpowiedzią cfeduke, stworzyłem tę funkcję, która używa IndexOf do znalezienia starej wartości w ciągu, a następnie zastępuje ją nową wartością. Użyłem tego w skrypcie SSIS przetwarzającym miliony wierszy, a metoda wyrażenia regularnego była znacznie wolniejsza niż ta.

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

Rozwijając popularną odpowiedź C. Dragon 76 , zmieniając jego kod w rozszerzenie, które przeciąża domyślną Replacemetodę.

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

Na podstawie odpowiedzi Jeffa Reddy'ego, z pewnymi optymalizacjami i walidacjami:

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

wersja podobna do C. Dragon's, ale jeśli potrzebujesz tylko jednego zamiennika:

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

Oto kolejna opcja wykonania zamiany Regex, ponieważ wydaje się, że niewiele osób zauważa, że ​​dopasowania zawierają lokalizację w ciągu:

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

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

Metoda wyrażeń regularnych powinna działać. Jednak to, co możesz zrobić, to ciąg znaków z bazy danych małymi literami, małe zmienne%, które masz, a następnie zlokalizuj pozycje i długości w łańcuchu małych liter z bazy danych. Pamiętaj, że pozycje w ciągu nie zmieniają się tylko dlatego, że są małe.

Następnie za pomocą pętli, która idzie w odwrotnym kierunku (jest łatwiej, jeśli nie musisz, musisz mieć bieżącą liczbę miejsc, do których przenoszą się późniejsze punkty), usuń z bazy danych ciąg znaków innych niż małe litery z bazy danych zmienne% według ich pozycji i długość i wstaw wartości zastępcze.

(Ponieważ wszyscy to robią). Oto moja wersja (z zerowymi testami oraz poprawnym wprowadzaniem i zastępowaniem znaków zastępczych) ** Inspirowane z internetu i innych wersji:

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

Stosowanie:

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

Pozwól, że przedstawię moją sprawę, a jeśli chcesz, możesz mnie rozerwać na strzępy.

Regex nie jest odpowiedzią na ten problem - relatywnie zbyt wolny i głodny pamięci.

StringBuilder jest znacznie lepszy niż string-string.

Ponieważ będzie to metoda rozszerzenia w celu uzupełnienia string.Replace, uważam, że ważne jest dopasowanie sposobu, w jaki to działa - dlatego ważne jest zgłaszanie wyjątków dla tych samych problemów argumentów, podobnie jak zwracanie oryginalnego ciągu, jeśli nie dokonano zamiany.

Uważam, że posiadanie parametru StringComparison nie jest dobrym pomysłem. Próbowałem, ale przypadek testowy pierwotnie wspomniany przez Michaela-Liu wykazał problem:

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

Podczas gdy IndexOf będzie pasować, istnieje niedopasowanie między długością dopasowania w ciągu źródłowym (1) a oldValue.Length (2). Przejawiało się to przez spowodowanie IndexOutOfRange w niektórych innych rozwiązaniach, gdy oldValue.Length został dodany do bieżącej pozycji dopasowania i nie mogłem znaleźć sposobu na obejście tego. Regex i tak nie pasuje do przypadku, więc wybrałem pragmatyczne rozwiązanie polegające na użyciu tylko StringComparison.OrdinalIgnoreCasedla mojego rozwiązania.

Mój kod jest podobny do innych odpowiedzi, ale moim zdziwieniem jest to, że szukam dopasowania, zanim podejmę trud tworzenia StringBuilder. Jeśli nie zostanie znaleziony, można uniknąć potencjalnie dużej alokacji. Kod staje się następnie do{...}whilezamiastwhile{...}

Zrobiłem kilka obszernych testów w stosunku do innych odpowiedzi, które pojawiły się ułamkowo szybciej i zużyły nieco mniej pamięci.

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