Existe uma alternativa para string.Replace que não diferencia maiúsculas de minúsculas?

Preciso pesquisar uma string e substituir todas as ocorrências de %FirstName%e %PolicyAmount%com um valor extraído de um banco de dados. O problema é que a capitalização do Nome varia. Isso me impede de usar o String.Replace()método Eu vi páginas da web sobre o assunto que sugerem

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

No entanto, por algum motivo, quando eu tentar substituir %PolicyAmount%com $0, a substituição não ocorre. Suponho que isso tenha algo a ver com o cifrão sendo um caractere reservado na regex.

Existe outro método que eu possa usar que não envolva a limpeza da entrada para lidar com caracteres especiais de expressão regular?

Do MSDN
$ 0 - "Substitui a última substring correspondente ao número do número do grupo (decimal)."

No .NET, o grupo 0 de expressões regulares é sempre a correspondência inteira. Para um $ literal, você precisa

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

Parece que string.Replace deve ter uma sobrecarga que requer um StringComparisonargumento. Como não, você pode tentar algo como isto:

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

Um tipo de grupo confuso de respostas, em parte porque o título da pergunta é realmente muito maior do que a pergunta específica que está sendo feita. Depois de ler, não tenho certeza se alguma resposta está a algumas edições de assimilar todas as coisas boas aqui, então imaginei que tentaria resumir.

Aqui está um método de extensão que eu acho que evita as armadilhas mencionadas aqui e fornece a solução mais amplamente aplicável.

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

Assim...

• Este é um método de extensão @MarkRobinson
• Isso não tenta pular Regex @Helge (você realmente precisa fazer byte a byte se quiser farejar as cordas assim fora do Regex)
• Passa @MichaelLiu do caso de teste excelente , "œ".ReplaceCaseInsensitiveFind("oe", ""), embora ele pode ter tido um comportamento ligeiramente diferente em mente.

Infelizmente, o comentário do @HA de que você tem Escapetodos os três não está correto . O valor inicial enewValue não precisa ser.

Nota: você precisa, no entanto, escapar $s no novo valor que está inserindo se eles fizerem parte do que pareceria ser um marcador de "valor capturado" . Assim, os três cifrões no Regex.Replace dentro do Regex.Replace [sic]. Sem isso, algo assim quebra ...

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

Aqui está o erro:

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.

Para dizer a você, sei que as pessoas que se sentem confortáveis ​​com o Regex sentem que seu uso evita erros, mas muitas vezes ainda pareço de byte farejando seqüências de caracteres (mas só depois de ler Spolsky nas codificações ) para ter certeza absoluta de que está conseguindo o que quer. destinado a casos de uso importantes. Lembra-me de Crockford em " um pouco expressões regulares inseguras ". Com muita freqüência, escrevemos regexps que permitem o que queremos (se tivermos sorte), mas involuntariamente permitimos mais entradas (por exemplo, é $10realmente uma cadeia de "valor de captura" válida no meu novo regexp newValue, acima?) Porque não fomos atenciosos o suficiente . Ambos os métodos têm valor e encorajam diferentes tipos de erros não intencionais. Geralmente é fácil subestimar a complexidade.

Essa $fuga estranha (e que Regex.Escapenão escapou dos padrões de valores capturados $0como eu esperaria em valores de substituição) me deixou louca por um tempo. A programação é difícil (c) 1842

Aqui está um método de extensão. Não sei onde o encontrei.

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

}

Parece que o método mais fácil é simplesmente usar o método Replace que acompanha o .NET e existe desde o .NET 1.0:

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

Para usar esse método, você deve adicionar uma Referência ao Microsoft.VisualBasic em conjunto. Este assembly é uma parte padrão do tempo de execução .Net, não é um download extra ou está marcado como obsoleto.

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

Inspirado pela resposta de cfeduke, criei esta função que usa IndexOf para encontrar o valor antigo na string e depois o substitui pelo novo valor. Eu usei isso em um script SSIS processando milhões de linhas, e o método regex era muito mais lento que isso.

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

Expandindo a resposta popular de C. Dragon 76 , transformando seu código em uma extensão que sobrecarrega o Replacemétodo padrão .

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

Com base na resposta de Jeff Reddy, com algumas otimizações e validações:

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

uma versão semelhante à C. Dragon's, mas se você precisar apenas de uma única substituição:

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

Aqui está outra opção para executar substituições de Regex, pois poucas pessoas parecem perceber que as correspondências contêm o local dentro da cadeia:

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

O método de expressão regular deve funcionar. No entanto, o que você também pode fazer é minúscula a sequência do banco de dados, minúscula a% de variáveis% que você possui e, em seguida, localize as posições e comprimentos na sequência minúscula do banco de dados. Lembre-se, as posições em uma corda não mudam apenas porque é mais baixa.

Em seguida, usando um loop que é inverso (é mais fácil, se você não tiver, você terá que manter uma contagem contínua de onde os pontos posteriores se deslocam) remova da sua seqüência de caracteres não inferior do banco de dados as variáveis%% por sua posição e comprimento e insira os valores de substituição.

(Já que todo mundo está tentando fazer isso). Aqui está minha versão (com verificações nulas e escape correto de entrada e substituição) ** Inspirada na Internet e em outras versões:

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

Uso:

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

Deixe-me fazer o meu caso e então você pode me rasgar em pedaços, se quiser.

Regex não é a resposta para esse problema - muito lento e com fome de memória, relativamente falando.

StringBuilder é muito melhor que manipular string.

Como esse será um método de extensão para complementar string.Replace , acredito que é importante combinar como isso funciona - portanto, lançar exceções para os mesmos problemas de argumento é importante, assim como retornar a string original se uma substituição não tiver sido feita.

Acredito que ter um parâmetro StringComparison não é uma boa ideia. Eu tentei, mas o caso de teste mencionado originalmente por michael-liu mostrou um problema: -

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

Enquanto IndexOf corresponderá, há uma incompatibilidade entre o comprimento da correspondência na cadeia de origem (1) e no oldValue.Length (2). Isso se manifestou causando IndexOutOfRange em algumas outras soluções quando oldValue.Length foi adicionado à posição de correspondência atual e não consegui encontrar uma maneira de contornar isso. O Regex falha em corresponder ao caso, então tomei a solução pragmática de usar apenasStringComparison.OrdinalIgnoreCase para a minha solução.

Meu código é semelhante a outras respostas, mas minha opinião é que procuro uma correspondência antes de me dar ao trabalho de criar a StringBuilder. Se nenhum for encontrado, uma alocação potencialmente grande será evitada. O código então se torna um do{...}whilee não umwhile{...}

Fiz alguns testes extensivos com outras respostas e isso saiu um pouco mais rápido e usou um pouco menos de memória.

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