How do I remove multiple offending characters from my string?

Question

Here's my working code:

string Input;
string Output;

Input = data;
Output = Input.Replace(@")", "");

Here, I am simply removing the parentheses ")" from my string, if it exists. Now how do I expand the list of offending characters like ")" to include "(" and "-" as well?

I realize I can write 2 more Output-like statements, but I'm wondering if there is a better way...

Answer 1

If you're just doing a couple replacements (I see you're only doing three), the easiest way without worrying about Regex or StringBuilders is to chain three Replace calls into one statement:

Output = Input.Replace("(", "").Replace(")", "").Replace("-", "");

... which is marginally better than storing the result in Output every time.

Answer 2

Output = Regex.Replace(Input, "[()-]", "");

The [] characters in the expression create a character class. It doesn't match those character directly.

Answer 3

LINQ solution:

Output = new String(Input.Except("()-").ToArray());

Answer 4

As an alternative to Regex, it may be easier to manage as a collection of replacements and doing the replaces using a StringBuilder.

var replacements = new[] { ")", "-" };
var output = new StringBuilder(Input);
foreach (var r in replacements)
    output.Replace(r, string.Empty);

Answer 5

You can use Regex.Replace(), documented here.

Answer 6

You can use a List which contains your badwords. Now just use a foreach loop to iterate over it and replace every bad string.

StringBuilder output = new StringBuilder("(Hello) W,o.r;ld");
List<string> badwords = new List<string>();
badwords.Add("(");
badwords.Add(")");
badwords.Add(",");
badwords.Add(".");
badwords.Add(";");
badwords.ForEach(bad => output = output.Replace(bad, String.Empty));
//Result "Hello World"

Kind regards.

//Edit: Implemented changes suggested by Khan.

Answer 7

This will allow you to do same thing also

    private static string ReplaceBadWords(string[] BadStrings, string input)
    {
        StringBuilder sb = new StringBuilder(input);
        BadStrings.ToList().ForEach(b => 
        {
            if(b != "") 
            {
                sb = sb.Replace(b, string.Empty);
            }
        });

        return sb.ToString();
    }

Sample usage would be

        string[] BadStrings = new string[]
        {
            ")",
            "(",
            "random",
            ""
        };

        string input = "Some random text()";
        string output = ReplaceBadWords(BadStrings, input);

Answer 8

I'd probably use a regular expression as it's terse and to the point. If you're scared of regular expression, you can teach the computer to write them for you. Here's a simple class for cleaning strings: you just provide it with a list of invalid characters:

class StringCleaner
{
  private Regex regex ;

  public StringCleaner( string invalidChars ) : this ( (IEnumerable<char>) invalidChars )
  {
    return ;
  }
  public StringCleaner ( params char[] invalidChars ) : this( (IEnumerable<char>) invalidChars )
  {
    return ;
  }
  public StringCleaner( IEnumerable<char> invalidChars )
  {
    const string    HEX     = "0123456789ABCDEF" ;
    SortedSet<char> charSet = new SortedSet<char>( invalidChars ) ;
    StringBuilder   sb      = new StringBuilder( 2 + 6*charset.Count ) ;

    sb.Append('[') ;
    foreach ( ushort c in charSet )
    {
      sb.Append(@"\u" )
        .Append( HEX[ ( c >> 12 ) & 0x000F ] )
        .Append( HEX[ ( c >>  8 ) & 0x000F ] )
        .Append( HEX[ ( c >>  4 ) & 0x000F ] )
        .Append( HEX[ ( c >>  0 ) & 0x000F ] )
        ;
    }
    sb.Append(']') ;
    this.regex = new Regex( sb.ToString() ) ;
  }

  public string Clean( string s )
  {
    if ( string.IsNullOrEmpty(s) ) return s ;
    string value = this.regex.Replace(s,"") ;
    return value ;
  }

}

Once you have that, it's easy:

static void Main(string[] args)
{
  StringCleaner cleaner = new StringCleaner( "aeiou" ) ;
  string dirty = "The quick brown fox jumped over the lazy dog." ;
  string clean = cleaner.Clean(dirty) ;
  Console.WriteLine( clean ) ;
  return;
}

At the end of which clean is Th qck brwn fx jmpd vr th lzy dg.

Easy!