Existe-t-il une alternative à la chaîne? Remplacer qui est insensible à la casse?

Question

J'ai besoin de rechercher une chaîne de caractères et de les remplacer tous les événements de l' %FirstName% et %PolicyAmount% avec une valeur tirée d'une base de données. Le problème, c'est la capitalisation de Prénom varie. Qui m'empêche de l'aide de l' String.Replace() méthode. J'ai vu des pages web sur le sujet suggèrent que

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

Cependant, pour une raison quelconque, quand j'essaie de le remplacer %PolicyAmount% avec $0, le remplacement n'a jamais lieu. Je suppose qu'il a quelque chose à voir avec le signe dollar, étant d'un caractère réservé dans l'expression rationnelle.

Est-il une autre méthode que je peux utiliser n'implique pas de désinfection à l'entrée de traiter avec la regex caractères spéciaux?

Answer 1

Cela ressemble à string.Replace devrait avoir une surcharge qui prend un argument StringComparison. Comme ce n'est pas le cas, vous pouvez essayer quelque chose comme ceci:

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

Answer 2

De MSDN
$ 0 - "Remplace la dernière sous-chaîne correspondant au numéro de groupe (décimal)."

Dans le groupe d'expressions régulières .NET, 0 correspond toujours à la correspondance complète. Pour un $ littéral, vous devez

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

Answer 3

Une sorte de confusion groupe de réponses, en partie parce que le titre de la question est en fait beaucoup plus grande que la question précise qui est posée. Après la lecture de travers, je ne suis pas sûr que la réponse est un peu d'éditions à l'écart à partir de l'assimilation de toutes les bonnes choses ici, alors j'ai pensé que j'allais essayer de somme.

Voici une méthode d'extension qui, je pense, évite les écueils mentionnés ici et fournit le plus largement applicable solution.

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

Alors...

• C'est une méthode d'extension @MarkRobinson
• Ce n'essayez pas de sauter Regex @Helge (que vous avez à faire, octet par octet, si vous voulez chaîne de renifler comme ça à l'extérieur de Regex)
• Passe @MichaelLiu ' excellent cas de test, "œ".ReplaceCaseInsensitiveFind("oe", ""), mais il peut avoir eu un comportement légèrement différent dans l'esprit.

Malheureusement, @HA 'commentaire que vous avez à l' Escape tous les trois n'est pas correct. La valeur initiale et newValue n'a pas besoin d'être.

Remarque: Vous n'avez, cependant, ont pour échapper $s dans la nouvelle valeur que vous êtes l'insertion s'ils font partie de ce qui semble être un "capturé" valeur de marqueur. Ainsi, les trois signes dollar dans la Regex.Remplacer dans l'expression rationnelle.Remplacer [sic]. Sans cela, quelque chose comme cela casse...

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

Voici l'erreur:

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.

Dites-vous ce que je connais des gens qui y sont à l'aise avec la Regex l'impression que leur utilisation permet d'éviter les erreurs, mais je suis encore souvent partielle à l'octet de renifler des chaînes de caractères (mais seulement après avoir lu Spolsky sur les encodages) pour être absolument sûr que vous obtenez ce que vous avez prévu pour important de cas d'utilisation. Me rappelle de Crockford sur "l'insécurité expressions régulières" un peu. Trop souvent, nous écrire les expressions régulières qui permettent à ce que nous voulons (si on a de la chance), mais involontairement permettre plus (par exemple, Est - $10 vraiment valable "la captation de la valeur" chaîne dans mon newValue regexp, ci-dessus?) parce que nous n'étions pas assez réfléchie. Les deux méthodes ont de la valeur, et à la fois d'encourager les différents types d'erreurs involontaires. Il est souvent facile de sous-estimer la complexité.

Bizarre $ s'échapper (et qu' Regex.Escape n'a pas échappé à capturé modèles de valeur comme $0 que je me serais attendu à des valeurs de remplacement) m'ont rendu fou pendant un certain temps. La programmation Est Dur (c) 1842

Answer 4

Semble la méthode la plus simple est simplement d'utiliser la méthode Replace qui est livré avec .Net et a été autour depuis. Net 1.0:

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

Answer 5

Voici une méthode d'extension. Je ne sais pas où je l'ai trouvé.

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

}