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

Al buscar una respuesta a esta pregunta, me he encontrado con otras similares que utilizan LINQ, pero no he podido entenderlas completamente (y, por lo tanto, implementarlas), ya que no estoy familiarizado con ella. 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 es así, obtén ese elemento.

Sinceramente, no sé cómo haría para hacer 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 regresa 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, verificará si hay un elemento que coincida con la cadena.

Aún así, no tengo idea de cómo resolver este problema, pero creo 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 respondedor me explique el uso de LINQ en su ejemplo (como dije, no me he molestado en mi tiempo con C #). Gracias de antemano chicos (y chicas).

EDITAR: se me ocurrió una solución; simplemente recorra la lista, verifique si el elemento actual contiene la cadena y luego configure una cadena igual al elemento actual. Sin embargo, me pregunto, ¿hay una forma 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ía 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: necesita iterar a través del 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 contiene 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 Containsmétodo distingue entre mayúsculas y minúsculas.

Puede usar el FirstOrDefaultmétodo de extensión de Linq :

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

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

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

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

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

Muchas buenas respuestas aquí, pero uso una simple usando 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);
}

Deberías poder usar algo como esto, me ha funcionado bien:

var valuesToMatch = yourList.Where(stringCheck => stringCheck.Contains(myString));

o algo como esto, si necesita mirar donde no coincide.

 var valuesToMatch = yourList.Where(stringCheck => !stringCheck.Contains(myString));

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 recopilación de datos. Puede usar la sintaxis como una consulta de base de datos (seleccionar, dónde, etc.) en una colección (aquí la colección (lista) de cadenas).

así que estás haciendo como "conseguirme elementos de la lista donde satisface una condición dada"

dentro de donde está utilizando una "expresión lambda"

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

entonces 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 cumple la condición.

Para que sea simple, use 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, use esto;

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

No he visto la opción bool en otras respuestas, así que espero que el siguiente código ayude a alguien.

Solo usa Any()

string myString = "test";
bool exists = myList
             .Where(w => w.COLUMN_TO_CHECK.Contains(myString)).Any();

Es posible combinar Any, Where, First y FirstOrDefault; o simplemente coloque el predicado en cualquiera de esos métodos dependiendo de lo que se necesite.

Probablemente debería evitar usar First a menos que desee que se lance una excepción cuando no se encuentre ninguna coincidencia. FirstOrDefault suele ser la mejor opción siempre que sepa que devolverá el valor predeterminado del tipo si no se encuentra una coincidencia (el valor predeterminado de la cadena es nulo, int es 0, bool es falso, etc.).

using System.Collections.Generic;
using System.Linq;


bool exists;
string firstMatch;
IEnumerable<string> matchingList;

var myList = new List<string>() { "foo", "bar", "foobar" };

exists = myList.Any(x => x.Contains("o"));
// exists => true

firstMatch = myList.FirstOrDefault(x => x.Contains("o"));
firstMatch = myList.First(x => x.Contains("o"));
// firstMatch => "foo"

firstMatch = myList.First(x => x.Contains("dark side"));
// throws exception because no element contains "dark side"

firstMatch = myList.FirstOrDefault(x => x.Contains("dark side"));
// firstMatch => null

matchingList = myList.Where(x => x.Contains("o")); 
// matchingList => { "foo", "foobar" }

Pruebe este código @ https://rextester.com/TXDL57489