Remover caracteres da string C #

Como posso remover caracteres de uma string? Por exemplo: "My name @is ,Wan.;'; Wan" .

Eu gostaria de remover os caracteres '@', ',', '.', ';', '\'' Dessa string para que ela se torne "My name is Wan Wan"

 var str = "My name @is ,Wan.;'; Wan"; var charsToRemove = new string[] { "@", ",", ".", ";", "'" }; foreach (var c in charsToRemove) { str = str.Replace(c, string.Empty); } 

Mas eu posso sugerir outra abordagem se você quiser remover todos os caracteres que não sejam letras

 var str = "My name @is ,Wan.;'; Wan"; str = new string((from c in str where char.IsWhiteSpace(c) || char.IsLetterOrDigit(c) select c ).ToArray()); 

Simples:

 String.Join("", "My name @is ,Wan.;'; Wan".Split('@', ',' ,'.' ,';', '\'')); 

Soa como uma aplicação ideal para RegEx – um mecanismo projetado para manipulação rápida de texto. Nesse caso:

 Regex.Replace("He\"ll,o Wo'r.ld", "[@,\\.\";'\\\\]", string.Empty) 

Menos específico para a sua pergunta, é possível remover toda a pontuação de uma string (exceto espaço), listando os caracteres aceitáveis ​​em uma expressão regular:

 string dirty = "My name @is ,Wan.;'; Wan"; // only space, capital AZ, lowercase az, and digits 0-9 are allowed in the string string clean = Regex.Replace(dirty, "[^A-Za-z0-9 ]", ""); 

Observe que há um espaço depois disso 9 para não remover espaços de sua sentença. O terceiro argumento é uma cadeia vazia que serve para replace qualquer substring que não pertence à expressão regular.

  string x = "My name @is ,Wan.;'; Wan"; string modifiedString = x.Replace("@", "").Replace(",", "").Replace(".", "").Replace(";", "").Replace("'", ""); 

A maneira mais simples seria usar String.Replace :

 String s = string.Replace("StringToReplace", "NewString"); 

Outra solução simples:

 var forbiddenChars = @"@,.;'".ToCharArray(); var dirty = "My name @is ,Wan.;'; Wan"; var clean = new string(dirty.Where(c => !forbiddenChars.Contains(c)).ToArray()); 
 new List { "@", ",", ".", ";", "'" }.ForEach(m => str = str.Replace(m, "")); 

Uma string é apenas uma matriz de caracteres, então use o Linq para fazer a substituição (similar ao Albin acima, exceto pelo uso de uma instrução linq contains para fazer a substituição):

 var resultString = new string( (from ch in "My name @is ,Wan.;'; Wan" where ! @"@,.;\'".Contains(ch) select ch).ToArray()); 

A primeira string é a string para replace chars e a segunda é uma string simples contendo os caracteres

Eu poderia muito bem jogar isso aqui.

Faça uma extensão para remover chars de uma string:

 public static string RemoveChars(this string input, params char[] chars) { var sb = new StringBuilder(); for (int i = 0; i < input.Length; i++) { if (!chars.Contains(input[i])) sb.Append(input[i]); } return sb.ToString(); } 

E é utilizável assim:

 string str = "My name @is ,Wan.;'; Wan"; string cleanedUpString = str.RemoveChars('@', ',', '.', ';', '\''); 

Ou apenas assim:

 string str = "My name @is ,Wan.;'; Wan".RemoveChars('@', ',', '.', ';', '\''); 

Muitas boas respostas aqui, aqui está minha adição junto com vários testes unitários que podem ser usados ​​para ajudar a testar correção, minha solução é similar a acima descrita por Rianne, mas usa um ISet para fornecer O (1) tempo de pesquisa nos caracteres substitutos (e também semelhante à solução Linq do @Albin Sunnanbo).

  using System; using System.Collections.Generic; using System.Linq; ///  /// Returns a string with the specified characters removed. ///  /// The string to filter. /// The characters to remove. /// A new  with the specified characters removed. public static string Remove(this string source, IEnumerable removeCharacters) { if (source == null) { throw new ArgumentNullException("source"); } if (removeCharacters == null) { throw new ArgumentNullException("removeCharacters"); } // First see if we were given a collection that supports ISet ISet replaceChars = removeCharacters as ISet; if (replaceChars == null) { replaceChars = new HashSet(removeCharacters); } IEnumerable filtered = source.Where(currentChar => !replaceChars.Contains(currentChar)); return new string(filtered.ToArray()); } 

NUnit (2.6+) testa aqui

 using System; using System.Collections; using System.Collections.Generic; using NUnit.Framework; [TestFixture] public class StringExtensionMethodsTests { [TestCaseSource(typeof(StringExtensionMethodsTests_Remove_Tests))] public void Remove(string targetString, IEnumerable removeCharacters, string expected) { string actual = StringExtensionMethods.Remove(targetString, removeCharacters); Assert.That(actual, Is.EqualTo(expected)); } [TestCaseSource(typeof(StringExtensionMethodsTests_Remove_ParameterValidation_Tests))] public void Remove_ParameterValidation(string targetString, IEnumerable removeCharacters) { Assert.Throws(() => StringExtensionMethods.Remove(targetString, removeCharacters)); } } internal class StringExtensionMethodsTests_Remove_Tests : IEnumerable { public IEnumerator GetEnumerator() { yield return new TestCaseData("My name @is ,Wan.;'; Wan", new char[] { '@', ',', '.', ';', '\'' }, "My name is Wan Wan").SetName("StringUsingCharArray"); yield return new TestCaseData("My name @is ,Wan.;'; Wan", new HashSet { '@', ',', '.', ';', '\'' }, "My name is Wan Wan").SetName("StringUsingISetCollection"); yield return new TestCaseData(string.Empty, new char[1], string.Empty).SetName("EmptyStringNoReplacementCharactersYieldsEmptyString"); yield return new TestCaseData(string.Empty, new char[] { 'A', 'B', 'C' }, string.Empty).SetName("EmptyStringReplacementCharsYieldsEmptyString"); yield return new TestCaseData("No replacement characters", new char[1], "No replacement characters").SetName("StringNoReplacementCharactersYieldsString"); yield return new TestCaseData("No characters will be replaced", new char[] { 'Z' }, "No characters will be replaced").SetName("StringNonExistantReplacementCharactersYieldsString"); yield return new TestCaseData("AaBbCc", new char[] { 'a', 'C' }, "ABbc").SetName("CaseSensitivityReplacements"); yield return new TestCaseData("ABC", new char[] { 'A', 'B', 'C' }, string.Empty).SetName("AllCharactersRemoved"); yield return new TestCaseData("AABBBBBBCC", new char[] { 'A', 'B', 'C' }, string.Empty).SetName("AllCharactersRemovedMultiple"); yield return new TestCaseData("Test That They Didn't Attempt To Use .Except() which returns distinct characters", new char[] { '(', ')' }, "Test That They Didn't Attempt To Use .Except which returns distinct characters").SetName("ValidateTheStringIsNotJustDistinctCharacters"); } } internal class StringExtensionMethodsTests_Remove_ParameterValidation_Tests : IEnumerable { public IEnumerator GetEnumerator() { yield return new TestCaseData(null, null); yield return new TestCaseData("valid string", null); yield return new TestCaseData(null, new char[1]); } } 

Parece que o caminho mais curto é combinar LINQ e string.Concat :

 var input = @"My name @is ,Wan.;'; Wan"; var chrs = new[] {'@', ',', '.', ';', '\''}; var result = string.Concat(input.Where(c => !chrs.Contains(c))); // => result = "My name is Wan Wan" 

Veja a demonstração em C # . Observe que string.Concat é um atalho para string.Join("", ...) .

Observe que usar um regex para remover caracteres individuais conhecidos ainda é possível construir dinamicamente, embora se acredite que o regex seja mais lento. No entanto, aqui está uma maneira de construir um regex dynamic (onde tudo que você precisa é de uma class de caractere):

 var pattern = $"[{Regex.Escape(new string(chrs))}]+"; var result = Regex.Replace(input, pattern, string.Empty); 

Veja outra demonstração em C # . O regex se parecerá com [@,\.;']+ (correspondendo a uma ou mais ( + ) ocorrências consecutivas de @ Regex.Escape . , Ou ' chars) onde o ponto não precisa ser escapado, mas Regex.Escape será necessário escaping de outros caracteres que devem ser escapados, como \ , ^ , ] ou - cuja posição dentro da class de caracteres você não pode prever.

Old School no lugar copiar / stomp:

  private static string RemoveDirtyCharsFromString(string in_string) { int index = 0; int removed = 0; byte[] in_array = Encoding.UTF8.GetBytes(in_string); foreach (byte element in in_array) { if ((element == ' ') || (element == '-') || (element == ':')) { removed++; } else { in_array[index] = element; index++; } } Array.Resize(ref in_array, (in_array.Length - removed)); return(System.Text.Encoding.UTF8.GetString(in_array, 0, in_array.Length)); } 

Não tenho certeza sobre a eficiência de outros methods (ou seja, a sobrecarga de todas as chamadas de function e instanciações que acontecem como um efeito colateral na execução de C #).

Comparando várias sugestões (bem como comparando no contexto de substituições de um único caractere com vários tamanhos e posições do alvo).

Neste caso particular, dividir nos alvos e unir nas substituições (neste caso, corda vazia) é o mais rápido em pelo menos um fator de 3. Finalmente, o desempenho é diferente dependendo do número de substituições, onde as substituições estão em a fonte e o tamanho da fonte. #ymmv

Resultados

(resultados completos aqui )

 | Test | Compare | Elapsed | |---------------------------|---------|--------------------------------------------------------------------| | SplitJoin | 1.00x | 29023 ticks elapsed (2.9023 ms) [in 10K reps, 0.00029023 ms per] | | Replace | 2.77x | 80295 ticks elapsed (8.0295 ms) [in 10K reps, 0.00080295 ms per] | | RegexCompiled | 5.27x | 152869 ticks elapsed (15.2869 ms) [in 10K reps, 0.00152869 ms per] | | LinqSplit | 5.43x | 157580 ticks elapsed (15.758 ms) [in 10K reps, 0.0015758 ms per] | | Regex, Uncompiled | 5.85x | 169667 ticks elapsed (16.9667 ms) [in 10K reps, 0.00169667 ms per] | | Regex | 6.81x | 197551 ticks elapsed (19.7551 ms) [in 10K reps, 0.00197551 ms per] | | RegexCompiled Insensitive | 7.33x | 212789 ticks elapsed (21.2789 ms) [in 10K reps, 0.00212789 ms per] | | Regex Insentive | 7.52x | 218164 ticks elapsed (21.8164 ms) [in 10K reps, 0.00218164 ms per] | 

Test Harness (LinqPad)

(nota: o Perf e Vs são extensões de tempo que eu escrevi )

 void test(string title, string sample, string target, string replacement) { var targets = target.ToCharArray(); var tox = "[" + target + "]"; var x = new Regex(tox); var xc = new Regex(tox, RegexOptions.Compiled); var xci = new Regex(tox, RegexOptions.Compiled | RegexOptions.IgnoreCase); // no, don't dump the results var p = new Perf/**/(); p.Add(string.Join(" ", title, "Replace"), n => targets.Aggregate(sample, (res, curr) => res.Replace(new string(curr, 1), replacement))); p.Add(string.Join(" ", title, "SplitJoin"), n => String.Join(replacement, sample.Split(targets))); p.Add(string.Join(" ", title, "LinqSplit"), n => String.Concat(sample.Select(c => targets.Contains(c) ? replacement : new string(c, 1)))); p.Add(string.Join(" ", title, "Regex"), n => Regex.Replace(sample, tox, replacement)); p.Add(string.Join(" ", title, "Regex Insentive"), n => Regex.Replace(sample, tox, replacement, RegexOptions.IgnoreCase)); p.Add(string.Join(" ", title, "Regex, Uncompiled"), n => x.Replace(sample, replacement)); p.Add(string.Join(" ", title, "RegexCompiled"), n => xc.Replace(sample, replacement)); p.Add(string.Join(" ", title, "RegexCompiled Insensitive"), n => xci.Replace(sample, replacement)); var trunc = 40; var header = sample.Length > trunc ? sample.Substring(0, trunc) + "..." : sample; p.Vs(header); } void Main() { // also see https://stackoverflow.com/questions/7411438/remove-characters-from-c-sharp-string "Control".Perf(n => { var s = "*"; }); var text = "My name @is ,Wan.;'; Wan"; var clean = new[] { '@', ',', '.', ';', '\'' }; test("stackoverflow", text, string.Concat(clean), string.Empty); var target = "o"; var f = "x"; var replacement = "1"; var fillers = new Dictionary { { "short", new String(f[0], 10) }, { "med", new String(f[0], 300) }, { "long", new String(f[0], 1000) }, { "huge", new String(f[0], 10000) } }; var formats = new Dictionary { { "start", "{0}{1}{1}" }, { "middle", "{1}{0}{1}" }, { "end", "{1}{1}{0}" } }; foreach(var filler in fillers) foreach(var format in formats) { var title = string.Join("-", filler.Key, format.Key); var sample = string.Format(format.Value, target, filler.Value); test(title, sample, target, replacement); } } 

Eu faço o método de extensão e com array de string, eu acho que string[] é mais útil que char[] porque char também pode ser string:

 public static class Helper { public static string RemoverStrs(this string str, string[] removeStrs) { foreach (var removeStr in removeStrs) str = str.Replace(removeStr, ""); return str; } } 

então você pode usá-lo em qualquer lugar:

 string myname = "My name @is ,Wan.;'; Wan"; string result = myname.RemoveStrs(new[]{ "@", ",", ".", ";", "\\"}); 

Eu precisava remover caracteres especiais de um arquivo XML. Aqui está como eu fiz isso. char.ToString () é o herói neste código.

 string item = "" char DC4 = (char)0x14; string fixed = item.Replace(DC4.ToString(), string.Empty);