Entfernen Sie Zeichen aus der C # -Zeichenfolge

Wie kann ich Zeichen aus einer Zeichenfolge entfernen? Zum Beispiel: "My name @is ,Wan.;'; Wan" .

Ich möchte die Zeichen '@', ',', '.', ';', '\'' Aus dieser Zeichenfolge entfernen, so dass sie zu "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); } 

Aber ich kann einen anderen Ansatz vorschlagen, wenn Sie alle nicht Buchstabenzeichen entfernen möchten

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

Einfach:

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

Klingt wie eine ideale Anwendung für RegEx – eine Engine für schnelle Textmanipulation. In diesem Fall:

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

Weniger spezifisch für Ihre Frage, es ist möglich, ALLE Interpunktionszeichen aus einer Zeichenfolge (außer Leerzeichen) zu entfernen, indem Sie die zulässigen Zeichen in einem regulären Ausdruck in weißer Farbe auflisten:

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

Beachten Sie, dass hinter dem Wert 9 ein Leerzeichen steht, um Leerzeichen aus dem Satz nicht zu entfernen. Das dritte Argument ist eine leere Zeichenfolge, die dazu dient, alle Teilstrings zu ersetzen, die nicht zum regulären Ausdruck gehören.

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

Der einfachste Weg wäre die Verwendung von String.Replace :

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

Eine weitere einfache Lösung:

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

Eine Zeichenkette ist nur ein Zeichen-Array, also benutze Linq, um die Ersetzung durchzuführen (ähnlich zu Albin oben, außer dass eine linq contains-statement zum Ersetzen verwendet wird):

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

Die erste Zeichenfolge ist die Zeichenfolge, die Zeichen ersetzen soll, und die zweite Zeichenfolge ist eine einfache Zeichenfolge mit den Zeichen

Ich könnte das genauso gut hier rauscasting.

Erstellen Sie eine Erweiterung, um Zeichen aus einer Zeichenfolge zu entfernen:

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

Und es ist so nutzbar:

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

Oder einfach so:

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

Viele gute Antworten hier, hier ist meine Ergänzung zusammen mit einigen Komponententests, die verwendet werden können, um zu helfen, Korrektheit zu testen, meine Lösung ist ähnlich zu @ Riannes oben, aber verwendet ein ISet, um O (1) Nachschlagezeit auf die Ersatzzeichen zu bieten (und auch ähnlich wie die Linq-Lösung von @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+) testet hier

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

Es scheint, dass der kürzeste Weg ist, LINQ und string.Concat zu kombinieren:

 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" 

Siehe die C # -Demo . Beachten Sie, dass string.Concat eine Verknüpfung zu string.Join("", ...) .

Beachten Sie, dass die Verwendung einer Regex zum Entfernen einzelner bekannter Zeichen weiterhin dynamisch erstellt werden kann, obwohl angenommen wird, dass Regex langsamer ist. Hier ist jedoch eine Möglichkeit, eine solche dynamische Regex zu erstellen (wo Sie nur eine Zeichenklasse benötigen):

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

Sehen Sie sich eine andere C # -Demo an . Die Regex sieht folgendermaßen aus: [@,\.;']+ (Entspricht einem oder mehreren ( + ) aufeinander folgenden Vorkommen von @ Regex.Escape . , ; Oder ' Zeichen), wobei der Punkt nicht Regex.Escape werden muss, sondern Regex.Escape wird benötigt, um anderen Zeichen zu entgehen, die entkoppelt werden müssen, wie \ , ^ , ] oder - deren Position innerhalb der Charakterklasse nicht vorhergesagt werden kann.

Old School in Ort kopieren / stampfen:

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

Nicht sicher über die Effizienz anderer Methoden (dh der Overhead aller functionsaufrufe und Instanziierungen, die als Nebeneffekt in der C # -Ausführung auftreten).

Vergleich verschiedener Vorschläge (sowie Vergleich im Kontext von Einzelzeichen-Ersetzungen mit verschiedenen Größen und Positionen des Ziels).

In diesem speziellen Fall ist das Aufteilen auf die Ziele und das Verbinden mit den Ersetzungen (in diesem Fall eine leere Zeichenfolge) um mindestens den Faktor 3 am schnellsten. Letztendlich ist die performance abhängig von der Anzahl der Ersetzungen, in denen sich die Ersetzungen befinden die Quelle und die Größe der Quelle. #ymmv

Ergebnisse

(Vollständige Ergebnisse hier )

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

Testkabel (LinqPad)

(Hinweis: die Perf und Vs sind Timing-Erweiterungen, die ich geschrieben habe )

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

Ich mache es Erweiterung Methode und mit String-Array, ich denke, string[] ist sinnvoller als char[] da char auch String sein kann:

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

dann kannst du es überall verwenden:

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

Ich musste Sonderzeichen aus einer XML-Datei entfernen. Hier ist, wie ich es gemacht habe. char.ToString () ist der Held in diesem Code.

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