Reguläre Ausdrücke ersetzen bestimmte Zeichen

  • Kennt jemand eine bessere / sauberere Methode, um Folgendes zu schreiben:

     GetSafeTagName(txtUserInput.text);
    
    public static string GetSafeTagName(string tag)
    {
        tag = tag.ToUpper()
        .Replace("'","`")
        .Replace('"','`')
        .Replace("&", "and")
        .Replace(",",":")
        .Replace(@"\","/"); //Do not allow escaped characters from user
        tag = Regex.Replace(tag, @"\s+", " "); //multiple spaces with single spaces
        return tag;
    }
     

    Danke!

    09 November 2011
    Todd
3 answers
  • Sie können einen regulären Ausdruck und Dictionary<string, string> verwenden, um die Suche zu ersetzen:

     // This regex matches either one of the special characters, or a sequence of 
    // more than one whitespace characters.
    Regex regex = new Regex("['\"&,\\\\]|\\s{2,}");
    
    var map = new Dictionary<string, string> {
        { "'", "`"},
        { "\"", "`"},
        { "&", "and" },
        { ",", ":" },
        { "\\", "/" }
    };
    
    // If the length of the match is greater that 1, then it's a sequence
    // of spaces, and we can replace it by a single space. Otherwise, we
    // use the dictionary to map the character.
    string output = regex.Replace(input.ToUpper(), 
        m => m.Value.Length > 1 ? " " : map[m.Value]);
     
    09 November 2011
    Elian Ebbing
  • Als ich etwas Ähnliches tun musste, definierte ich die Ersetzungen mit einem Dictionary<string, string>.

    Und dann sollte Folgendes ersetzt werden:

     foreach( KeyValuePair<string, string> pair in replacements)
    {
        str = str.Replace(pair.Key, pair.Value);
    }
     

    http://msdn.microsoft.com/de-de/library/5tbh8a42.aspx

    09 November 2011
    ANeves
  • Ich denke, Ihre Methode ist so gut lesbar und sauber, wie sie ist. Wenn Sie jedoch die Methode selbst vereinfachen möchten, habe ich eine anständige Unterstützungsstruktur, die dies tun und möglicherweise für besonders lange Zeichenfolgen beschleunigen würde:

     internal static class SafeTag
    {
        private static readonly List<Replacement> replacements = new List<Replacement>
        {
            new Replacement("'", "`"),
            new Replacement("\"", "`"),
            new Replacement("&", "and"),
            new Replacement(",", ":"),
            new Replacement("\\", "/")
        };
    
        private static readonly Regex spaces = new Regex("\\s+", RegexOptions.Compiled);
    
        public static string GetSafeTagName(this string tag)
        {
            var parse = new StringBuilder(tag.ToUpper());
            replacements.ForEach(replacement => parse = parse.Replace(replacement.Original, replacement.ToReplaceWith));
            return spaces.Replace(parse.ToString(), " ");
        }
    
        private struct Replacement
        {
            private readonly string original;
    
            private readonly string toReplaceWith;
    
            internal Replacement(string original, string toReplaceWith)
            {
                this.original = original;
                this.toReplaceWith = toReplaceWith;
            }
    
            internal string Original
            {
                get
                {
                    return this.original;
                }
            }
    
            internal string ToReplaceWith
            {
                get
                {
                    return this.toReplaceWith;
                }
            }
        }
    }
     
    09 November 2011
    Jesse C. Slicer