Compruebe si la lista contiene un elemento que contiene una cadena y obtenga ese elemento

Mientras busco una respuesta a esta pregunta, me he topado con otras similares que utilizan LINQ, pero no he podido entenderlas por completo (y, por lo tanto, implementarlas), ya que no estoy familiarizada con ellas. Lo que me gustaría, básicamente, es esto:

  1. Compruebe si algún elemento de una lista contiene una cadena específica.
  2. Si lo hace, consigue ese elemento.

Sinceramente, no sé cómo haría eso. Lo que se me ocurre es esto (no funciona, por supuesto):

if (myList.Contains(myString)) string element = myList.ElementAt(myList.IndexOf(myString)); 

Sé por qué no funciona:

  • myList.Contains() no devuelve true , ya que verificará si un elemento completo de la lista coincide con la cadena que especifiqué.
  • myList.IndexOf() no encontrará una ocurrencia, ya que, como es el caso nuevamente, buscará un elemento que coincida con la cadena.

Aún así, no tengo ni idea de cómo resolver este problema, pero me imagino que tendré que usar LINQ como se sugiere en preguntas similares a las mías. Dicho esto, si ese es el caso aquí, me gustaría que el contestador me explicara el uso de LINQ en su ejemplo (como dije, no me he molestado en hacerlo con mi C #). Gracias de antemano chicos (y gals?).

EDIT: he encontrado una solución; simplemente recorra la lista, verifique si el elemento actual contiene la cadena y luego establezca una cadena igual al elemento actual. Me pregunto, sin embargo, ¿hay una manera más eficiente que esta?

 string myString = "bla"; string element = ""; for (int i = 0; i < myList.Count; i++) { if (myList[i].Contains(myString)) element = myList[i]; } 

Deberías poder usar Linq aquí:

 var matchingvalues = myList .Where(stringToCheck => stringToCheck.Contains(myString)); 

Si simplemente desea devolver el primer elemento coincidente:

 var match = myList .FirstOrDefault(stringToCheck => stringToCheck.Contains(myString)); if(match != null) //Do stuff 

La respuesta básica es: debe recorrer el bucle y verificar que cualquier elemento contenga la cadena especificada. Entonces, digamos que el código es:

 foreach(string item in myList) { if(item.Contains(myString)) return item; } 

El código equivalente, pero conciso, es:

 mylist.Where(x => x.Contains(myString)).FirstOrDefault(); 

Aquí, x es un parámetro que actúa como “elemento” en el código anterior.

 string result = myList.FirstOrDefault(x => x == myString) if(result != null) { //found } 
 for (int i = 0; i < myList.Length; i++) { if (myList[i].Contains(myString)) // (you use the word "contains". either equals or indexof might be appropriate) { return i; } } 

Los bucles antiguos son casi siempre los más rápidos.

Si desea una lista de cadenas que contienen su cadena:

 var newList = myList.Where(x => x.Contains(myString)).ToList(); 

Otra opción es usar Linq FirstOrDefault

 var element = myList.Where(x => x.Contains(myString)).FirstOrDefault(); 

Tenga en cuenta que el método Contains distingue entre mayúsculas y minúsculas.

Podría usar el método de extensión FirstOrDefault de Linq:

 string element = myList.FirstOrDefault(s => s.Contains(myString)); 

Esto devolverá el primer elemento que contiene la subcadena myString , o null si no se encuentra dicho elemento.

Si todo lo que necesita es el índice, use el método FindIndex la clase List :

 int index = myList.FindIndex(s => s.Contains(myString)); 

Esto devolverá el índice del primer elemento que contiene la subcadena myString , o -1 si no se encuentra dicho elemento.

puedes usar

 var match=myList.Where(item=>item.Contains("Required String")); foreach(var i in match) { //do something with the matched items } 

LINQ le proporciona capacidades para “consultar” cualquier recostackción de datos. Puede utilizar la syntax como una consulta de base de datos (selección, donde, etc.) en una colección (aquí la colección (lista) de cadenas).

por lo que está haciendo como “obtener elementos de la lista donde cumple una condición determinada”

dentro de donde está utilizando una “expresión lambda”

decir brevemente la expresión lambda es algo como (parámetro de entrada => valor de retorno)

así que para un parámetro “item”, devuelve “item.Contains (” string requerido “)”. Por lo tanto, devuelve verdadero si el elemento contiene la cadena y, por lo tanto, se selecciona de la lista ya que cumplió con la condición.

Para mantenerlo simple usa esto;

 foreach(string item in myList)//Iterate through each item. { if(item.Contains("Search Term")//True if the item contains search pattern. { return item;//Return the matched item. } } 

Alternativamente, para hacer esto con for loop, usa esto;

  for (int iterator = 0; iterator < myList.Count; iterator++) { if (myList[iterator].Contains("String Pattern")) { return myList[iterator]; } } 

Muchas buenas respuestas aquí, pero uso una simple utilizando Exists , como se muestra a continuación:

 foreach (var setting in FullList) { if(cleanList.Exists(x => x.ProcedureName == setting.ProcedureName)) setting.IsActive = true; // do you business logic here else setting.IsActive = false; updateList.Add(setting); }