Usando C # para verificar si la cadena contiene una cadena en una matriz de cadenas

Quiero usar C # para verificar si un valor de cadena contiene una palabra en una matriz de cadenas. Por ejemplo,

string stringToCheck = "text1text2text3"; string[] stringArray = { "text1", "someothertext", etc... }; if(stringToCheck.contains stringArray) //one of the items? { } 

¿Cómo puedo verificar si el valor de la cadena para ‘stringToCheck’ contiene una palabra en la matriz?

Aquí sabrás como podrás hacerlo:

 string stringToCheck = "text1"; string[] stringArray = { "text1", "testtest", "test1test2", "test2text1" }; foreach (string x in stringArray) { if (stringToCheck.Contains(x)) { // Process... } } 

ACTUALIZACIÓN: Puede ser que esté buscando una solución mejor … consulte la respuesta de @Anton Gogolev a continuación que hace uso de LINQ.

Así es cómo:

 if(stringArray.Any(stringToCheck.Contains)) /* or a bit longer: (stringArray.Any(s => stringToCheck.Contains(s))) */ 

Esto comprueba si stringToCheck contiene cualquiera de las subcadenas de stringArray . Si quiere asegurarse de que contiene todas las subcadenas, cambie Any to All :

 if(stringArray.All(stringToCheck.Contains)) 

Prueba esto:

No es necesario usar LINQ

 if (Array.IndexOf(array, Value) >= 0) { //Your stuff goes here } 

Solo use el método linq:

 stringArray.Contains(stringToCheck) 

(Lo siento, no puedo agregar un comentario sobre las respuestas existentes ya que mi reputación es <50)

La manera más fácil y de muestra.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck); 

Algo como esto quizás:

 string stringToCheck = "text1text2text3"; string[] stringArray = new string[] { "text1" }; if (Array.Exists(stringArray, (Predicate)delegate(string s) { return stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1; })) { Console.WriteLine("Found!"); } 
 string strName = "vernie"; string[] strNamesArray = { "roger", "vernie", "joel" }; if (strNamesArray.Any(x => x == strName)) { // do some action here if true... } 

Usar Linq y el grupo de métodos sería la manera más rápida y compacta de hacer esto.

 var arrayA = new[] {"element1", "element2"}; var arrayB = new[] {"element2", "element3"}; if (arrayB.Any(arrayA.Contains)) return true; 

Yo usaría Linq pero aún se puede hacer a través de:

 new[] {"text1", "text2", "etc"}.Contains(ItemToFind); 

Tratar:

 String[] val = { "helloword1", "orange", "grape", "pear" }; String sep = ""; string stringToCheck = "word1"; bool match = String.Join(sep,val).Contains(stringToCheck); bool anothermatch = val.Any(s => s.Contains(stringToCheck)); 

También puede hacer lo mismo que Anton Gogolev sugiere para verificar si algún elemento en stringArray1 coincide con cualquier elemento en stringArray2 :

 if(stringArray1.Any(stringArray2.Contains)) 

Y del mismo modo, todos los elementos en stringArray1 coinciden con todos los elementos en stringArray2:

 if(stringArray1.All(stringArray2.Contains)) 

Uso lo siguiente en una aplicación de consola para verificar argumentos

 var sendmail = args.Any( o => o.ToLower() == "/sendmail=true"); 

Puede definir sus propios string.ContainsAny() y string.ContainsAll() . Como extra, incluso he string.Contains() una string.Contains() método string.Contains() que permite una comparación insensible a mayúsculas y minúsculas, etc.

 public static class Extensions { public static bool Contains(this string source, string value, StringComparison comp) { return source.IndexOf(value, comp) > -1; } public static bool ContainsAny(this string source, IEnumerable values, StringComparison comp = StringComparison.CurrentCulture) { return values.Any(value => source.Contains(value, comp)); } public static bool ContainsAll(this string source, IEnumerable values, StringComparison comp = StringComparison.CurrentCulture) { return values.All(value => source.Contains(value, comp)); } } 

Puede probarlos con el siguiente código:

  public static void TestExtensions() { string[] searchTerms = { "FOO", "BAR" }; string[] documents = { "Hello foo bar", "Hello foo", "Hello" }; foreach (var document in documents) { Console.WriteLine("Testing: {0}", document); Console.WriteLine("ContainsAny: {0}", document.ContainsAny(searchTerms, StringComparison.OrdinalIgnoreCase)); Console.WriteLine("ContainsAll: {0}", document.ContainsAll(searchTerms, StringComparison.OrdinalIgnoreCase)); Console.WriteLine(); } } 

intente esto, aquí el ejemplo: Para verificar si el campo contiene alguna de las palabras en la matriz. Para verificar si el campo (algún Campo) contiene alguna de las palabras en el conjunto.

 String[] val = { "helloword1", "orange", "grape", "pear" }; Expression> someFieldFilter = i => true; someFieldFilter = i => val.Any(s => i.someField.Contains(s)); 
 public bool ContainAnyOf(string word, string[] array) { for (int i = 0; i < array.Length; i++) { if (word.Contains(array[i])) { return true; } } return false; } 

Usé un método similar al IndexOf de Maitrey684 y el bucle Foreach de Theomax para crear esto. (Nota: las primeras 3 líneas de “cadena” son solo un ejemplo de cómo se puede crear una matriz y obtener el formato adecuado).

Si desea comparar 2 matrices, estarán delimitadas por punto y coma, pero el último valor no tendrá una después. Si agrega un punto y coma a la forma de cadena de la matriz (es decir, a; b; c se convierte en; b; c;), puede hacer coincidir con “x;” no importa en qué posición se encuentre:

 bool found = false; string someString = "abc"; string[] arrString = someString.Split('-'); string myStringArray = arrString.ToString() + ";"; foreach (string s in otherArray) { if (myStringArray.IndexOf(s + ";") != -1) { found = true; break; } } if (found == true) { // .... } 
 string [] lines = {"text1", "text2", "etc"}; bool bFound = lines.Any(x => x == "Your string to be searched"); 

bEncontrar conjuntos en verdadero si la cadena buscada coincide con cualquier elemento de la matriz ‘líneas’.

Prueba esto

 string stringToCheck = "text1text2text3"; string[] stringArray = new string[] { "text1" }; var t = lines.ToList().Find(c => c.Contains(stringToCheck)); 

Le devolverá la línea con la primera incidencia del texto que está buscando.

Si stringArray contiene una gran cantidad de cadenas de longitud variadas, considere usar un Trie para almacenar y buscar en la matriz de cadenas.

 public static class Extensions { public static bool ContainsAny(this string stringToCheck, IEnumerable stringArray) { Trie trie = new Trie(stringArray); for (int i = 0; i < stringToCheck.Length; ++i) { if (trie.MatchesPrefix(stringToCheck.Substring(i))) { return true; } } return false; } } 

Aquí está la implementación de la clase Trie

 public class Trie { public Trie(IEnumerable words) { Root = new Node { Letter = '\0' }; foreach (string word in words) { this.Insert(word); } } public bool MatchesPrefix(string sentence) { if (sentence == null) { return false; } Node current = Root; foreach (char letter in sentence) { if (current.Links.ContainsKey(letter)) { current = current.Links[letter]; if (current.IsWord) { return true; } } else { return false; } } return false; } private void Insert(string word) { if (word == null) { throw new ArgumentNullException(); } Node current = Root; foreach (char letter in word) { if (current.Links.ContainsKey(letter)) { current = current.Links[letter]; } else { Node newNode = new Node { Letter = letter }; current.Links.Add(letter, newNode); current = newNode; } } current.IsWord = true; } private class Node { public char Letter; public SortedList Links = new SortedList(); public bool IsWord; } private Node Root; } 

Si todas las cadenas en stringArray tienen la misma longitud, será mejor que solo HashSet un HashSet lugar de un Trie

 public static bool ContainsAny(this string stringToCheck, IEnumerable stringArray) { int stringLength = stringArray.First().Length; HashSet stringSet = new HashSet(stringArray); for (int i = 0; i < stringToCheck.Length - stringLength; ++i) { if (stringSet.Contains(stringToCheck.Substring(i, stringLength))) { return true; } } return false; } 

Solución simple, no requerida

String.Join (“,”, array) .Contains (Value + “,”);

 int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase); 

Pruebe esto, no hay necesidad de un bucle ..

 string stringToCheck = "text1"; List stringList = new List() { "text1", "someothertext", "etc.." }; if (stringList.Exists(o => stringToCheck.Contains(o))) { } 

Usé el siguiente código para verificar si la cadena contenía alguno de los elementos en la matriz de cadenas:

 foreach (string s in stringArray) { if (s != "") { if (stringToCheck.Contains(s)) { Text = "matched"; } } } 

Tres opciones demostradas Prefiero encontrar el tercero como el más conciso.

 class Program { static void Main(string[] args) { string req = "PUT"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("one.1.A"); // IS TRUE } req = "XPUT"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("one.1.B"); // IS TRUE } req = "PUTX"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("one.1.C"); // IS TRUE } req = "UT"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("one.1.D"); // false } req = "PU"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("one.1.E"); // false } req = "POST"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("two.1.A"); // IS TRUE } req = "ASD"; if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) { Console.WriteLine("three.1.A"); // false } Console.WriteLine("-----"); req = "PUT"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("one.2.A"); // IS TRUE } req = "XPUT"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("one.2.B"); // false } req = "PUTX"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("one.2.C"); // false } req = "UT"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("one.2.D"); // false } req = "PU"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("one.2.E"); // false } req = "POST"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("two.2.A"); // IS TRUE } req = "ASD"; if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0) { Console.WriteLine("three.2.A"); // false } Console.WriteLine("-----"); req = "PUT"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("one.3.A"); // IS TRUE } req = "XPUT"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("one.3.B"); // false } req = "PUTX"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("one.3.C"); // false } req = "UT"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("one.3.D"); // false } req = "PU"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("one.3.E"); // false } req = "POST"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("two.3.A"); // IS TRUE } req = "ASD"; if ((new string[] {"PUT", "POST"}.Contains(req))) { Console.WriteLine("three.3.A"); // false } Console.ReadKey(); } }