Cómo verificar si una cadena contiene alguna de algunas cadenas

Quiero verificar si una cadena s contiene “a” o “b” o “c” en C #. Estoy buscando una solución más agradable que el uso

if (s.contains("a")||s.contains("b")||s.contains("c")) 

Si busca caracteres individuales, puede usar String.IndexOfAny() .

Si desea cadenas arbitrarias, entonces no conozco un método .NET para lograr eso “directamente”, aunque una expresión regular funcionaría.

Bueno, siempre hay esto:

 public static bool ContainsAny(this string haystack, params string[] needles) { foreach (string needle in needles) { if (haystack.Contains(needle)) return true; } return false; } 

Uso:

 bool anyLuck = s.ContainsAny("a", "b", "c"); 

Nada va a coincidir con el rendimiento de tu cadena de || comparaciones, sin embargo.

Aquí hay una solución LINQ que es prácticamente la misma pero más escalable:

 new[] { "a", "b", "c" }.Any(c => s.Contains(c)) 
 var values = new [] {"abc", "def", "ghj"}; var str = "abcedasdkljre"; values.Any(str.Contains); 

Puedes intentar con expresión regular

 string s; Regex r = new Regex ("a|b|c"); bool containsAny = r.IsMatch (s); 

Si necesita ContainsAny con un StringComparison específico (por ejemplo, para ignorar mayúsculas y minúsculas), puede utilizar este método de Extender cadenas.

 public static class StringExtensions { public static bool ContainsAny(this string input, IEnumerable containsKeywords, StringComparison comparisonType) { return containsKeywords.Any(keyword => input.IndexOf(keyword, comparisonType) >= 0); } } 

Uso con StringComparison.CurrentCultureIgnoreCase :

 var input = "My STRING contains Many Substrings"; var substrings = new[] {"string", "many substrings", "not containing this string" }; input.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase); // The statement above returns true. ”xyz”.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase); // This statement returns false. 

Esta es una “solución más agradable” y bastante simple

 if(new string[] { "A", "B", ... }.Any(s=>myString.Contains(s))) 

Como una cadena es una colección de caracteres, puede usar los métodos de extensión LINQ en ellos:

 if (s.Any(c => c == 'a' || c == 'b' || c == 'c')) ... 

Esto escaneará la cadena una vez y se detendrá en la primera aparición, en lugar de escanear la cadena una vez por cada carácter hasta que se encuentre una coincidencia.

Esto también se puede usar para cualquier expresión que desee, por ejemplo, verificando un rango de caracteres:

 if (s.Any(c => c >= 'a' && c < = 'c')) ... 
 public static bool ContainsAny(this string haystack, IEnumerable needles) { return needles.Any(haystack.Contains); } 
 // Nice method's name, @Dan Tao public static bool ContainsAny(this string value, params string[] params) { return params.Any(p => value.Compare(p) > 0); // or return params.Any(p => value.Contains(p)); } 

Any para cualquiera, All para cada

 List includedWords = new List() { "a", "b", "c" }; bool string_contains_words = includedWords.Exists(o => s.Contains(o)); 

Puedes usar expresiones regulares

 if(System.Text.RegularExpressions.IsMatch("a|b|c")) 
  static void Main(string[] args) { string illegalCharacters = "!@#$%^&*()\\/{}|<>,.~`?"; //We'll call these the bad guys string goodUserName = "John Wesson"; //This is a good guy. We know it. We can see it! //But what if we want the program to make sure? string badUserName = "*_Wesson*_John!?"; //We can see this has one of the bad guys. Underscores not restricted. Console.WriteLine("goodUserName " + goodUserName + (!HasWantedCharacters(goodUserName, illegalCharacters) ? " contains no illegal characters and is valid" : //This line is the expected result " contains one or more illegal characters and is invalid")); string captured = ""; Console.WriteLine("badUserName " + badUserName + (!HasWantedCharacters(badUserName, illegalCharacters, out captured) ? " contains no illegal characters and is valid" : //We can expect this line to print and show us the bad ones " is invalid and contains the following illegal characters: " + captured)); } //Takes a string to check for the presence of one or more of the wanted characters within a string //As soon as one of the wanted characters is encountered, return true //This is useful if a character is required, but NOT if a specific frequency is needed //ie. you wouldn't use this to validate an email address //but could use it to make sure a username is only alphanumeric static bool HasWantedCharacters(string source, string wantedCharacters) { foreach(char s in source) //One by one, loop through the characters in source { foreach(char c in wantedCharacters) //One by one, loop through the wanted characters { if (c == s) //Is the current illegalChar here in the string? return true; } } return false; } //Overloaded version of HasWantedCharacters //Checks to see if any one of the wantedCharacters is contained within the source string //string source ~ String to test //string wantedCharacters ~ string of characters to check for static bool HasWantedCharacters(string source, string wantedCharacters, out string capturedCharacters) { capturedCharacters = ""; //Haven't found any wanted characters yet foreach(char s in source) { foreach(char c in wantedCharacters) //Is the current illegalChar here in the string? { if(c == s) { if(!capturedCharacters.Contains(c.ToString())) capturedCharacters += c.ToString(); //Send these characters to whoever's asking } } } if (capturedCharacters.Length > 0) return true; else return false; } 

Si busca cadenas arbitrarias, y no solo caracteres, puede usar una sobrecarga de IndexOfAny que toma argumentos de cadena del nuevo proyecto NLib :

 if (s.IndexOfAny("aaa", "bbb", "ccc", StringComparison.Ordinal) >= 0)