Eliminar caracteres de la cadena C #

¿Cómo podría eliminar caracteres de una cadena? Por ejemplo: "My name @is ,Wan.;'; Wan" .

Me gustaría eliminar los caracteres '@', ',', '.', ';', '\'' De esa cadena para que se convierta en "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); } 

Pero puedo sugerir otro enfoque si quieres eliminar todos los caracteres que no sean 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()); 

Sencillo:

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

Suena como una aplicación ideal para RegEx, un motor diseñado para la manipulación de texto rápido. En este caso:

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

Menos específico para su pregunta, es posible eliminar TODA la puntuación de una cadena (excepto el espacio) con una lista blanca de los caracteres aceptables en una expresión 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 ]", ""); 

Tenga en cuenta que hay un espacio después de ese 9 para no eliminar espacios de su oración. El tercer argumento es una cadena vacía que sirve para reemplazar cualquier subcadena que no pertenece a la expresión regular.

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

La forma más simple sería usar String.Replace :

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

Otra solución simple:

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

Una cadena es solo una matriz de caracteres, entonces use Linq para hacer la sustitución (similar a Albin arriba, excepto que usa una instrucción linq contains para hacer la sustitución):

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

La primera cadena es la cadena para reemplazar caracteres en y la segunda es una cadena simple que contiene los caracteres

Bien podría arrojar esto aquí.

Haga una extensión para eliminar caracteres de una cadena:

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

Y es utilizable así:

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

O simplemente así:

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

Muchas buenas respuestas aquí, esta es mi adición junto con varias pruebas unitarias que pueden usarse para ayudar a evaluar la corrección, mi solución es similar a la anterior de @ Rianne pero usa un ISet para proporcionar O (1) tiempo de búsqueda en los caracteres de reemplazo (y también similar a la solución Linq de @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()); } 

Pruebas NUnit (2.6+) aquí

 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 el camino más corto es combinar LINQ y 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" 

Vea la demostración de C # . Tenga en cuenta que string.Concat es un atajo para string.Join("", ...) .

Tenga en cuenta que aún es posible construir dinámicamente el uso de una expresión regular para eliminar caracteres individuales conocidos, aunque se cree que la expresión regular es más lenta. Sin embargo, esta es una forma de crear una expresión regular dinámica (donde todo lo que necesitas es una clase de caracteres):

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

Ver otra demostración de C # . La expresión regular se verá como [@,\.;']+ (Coincidiendo con una o más ( + ) ocurrencias consecutivas de @ Regex.Escape . , ; O ' caracteres ' ) donde no se tiene que escapar el punto, pero Regex.Escape será necesario para escapar de otros caracteres que se deben escapar, como \ , ^ , ] o - cuya posición dentro de la clase de caracteres no se puede predecir.

Old School in place copy / 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)); } 

No estoy seguro acerca de la eficacia de otros métodos (es decir, la sobrecarga de todas las llamadas a funciones y las instancias que ocurren como un efecto secundario en la ejecución de C #).

Comparar varias sugerencias (así como comparar en el contexto de reemplazos de un solo personaje con varios tamaños y posiciones del objective).

En este caso particular, dividir los objectives y unir los reemplazos (en este caso, cadena vacía) es el más rápido por al menos un factor de 3. En última instancia, el rendimiento es diferente dependiendo del número de reemplazos, donde están los reemplazos la fuente y el tamaño de la fuente. #ymmv

Resultados

(resultados completos aquí )

 | 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] | 

Arnés de prueba (LinqPad)

(nota: el Perf y Vs son extensiones de tiempo que escribí )

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

Lo hago con el método de extensión y con el conjunto de cadenas, creo que string[] es más útil que char[] porque char también puede 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; } } 

entonces puedes usarlo en cualquier lugar:

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

Necesitaba eliminar caracteres especiales de un archivo XML. Así es como lo hice. char.ToString () es el héroe en este código.

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