Verifique se a lista contém um elemento que contém uma sequência e obtenha esse elemento

Enquanto procurava por uma resposta para essa pergunta, encontrei outras usando o LINQ, mas não consegui entendê-las completamente (e, portanto, implementá-las), pois não estou familiarizado com ela. O que eu gostaria, basicamente, é o seguinte:

1. Verifique se algum elemento de uma lista contém uma sequência específica.
2. Se isso acontecer, obtenha esse elemento.

Sinceramente, não sei como eu faria isso. O que posso pensar é isso (não está funcionando, é claro):

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

Eu sei por que não funciona:

• myList.Contains()não retorna true, pois verificará se um elemento inteiro da lista corresponde à sequência especificada.
• myList.IndexOf() não encontrará uma ocorrência, pois, como é o caso novamente, ele verificará se há um elemento correspondente à string.

Ainda assim, não tenho idéia de como resolver esse problema, mas acho que terei que usar o LINQ conforme sugerido em perguntas semelhantes às minhas. Dito isto, se esse for o caso aqui, eu gostaria que o respondente me explicasse o uso do LINQ no exemplo deles (como eu disse, não me importei com isso no meu tempo com C #). Agradeço desde já pessoal (e galões?).

EDIT: Eu vim com uma solução; basta percorrer a lista, verificar se o elemento atual contém a sequência e defina uma sequência igual ao elemento atual. Gostaria de saber, porém, existe uma maneira mais eficiente do que isso?

string myString = "bla";
string element = "";

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

Você deve poder usar o Linq aqui:

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

Se você deseja simplesmente devolver o primeiro item correspondente:

var match = myList
    .FirstOrDefault(stringToCheck => stringToCheck.Contains(myString));

if(match != null)
    //Do stuff

A resposta básica é: você precisa percorrer o loop e verificar se algum elemento contém a sequência especificada. Então, digamos que o código é:

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

O código equivalente, mas conciso, é:

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

Aqui, x é um parâmetro que age como "item" no código acima.

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

Loops à moda antiga são quase sempre os mais rápidos.

Se você deseja uma lista de cadeias contendo sua cadeia:

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

Outra opção é usar o Linq FirstOrDefault

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

Lembre-se de que o Containsmétodo diferencia maiúsculas de minúsculas.

Você pode usar o FirstOrDefaultmétodo de extensão do Linq :

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

Isso retornará o elemento fist que contém a substring myStringou nullse nenhum elemento for encontrado.

Se tudo o que você precisa é o índice, use o método List<T>da classe FindIndex:

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

Isso retornará o índice do elemento fist que contém a substring myStringou -1se nenhum elemento for encontrado.

Muitas boas respostas aqui, mas eu uso uma simples usando Existe , como abaixo:

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

Você deve poder usar algo como isto, funcionou bem para mim:

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

ou algo assim, se você precisar procurar onde não corresponde.

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

você pode usar

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

O LINQ fornece recursos para "consultar" qualquer coleção de dados. Você pode usar a sintaxe como uma consulta ao banco de dados (selecione, onde, etc) em uma coleção (aqui a coleção (lista) de cadeias).

então você está fazendo como "pegue itens da lista Onde ele satisfaz uma determinada condição"

dentro de Onde você está usando uma "expressão lambda"

dizer brevemente que a expressão lambda é algo como (parâmetro de entrada => valor de retorno)

portanto, para um parâmetro "item", ele retorna "item.Contains (" required string ")". Portanto, ele retornará true se o item contiver a string e, assim, for selecionado na lista, pois satisfez a condição.

Para simplificar, use isso;

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.
 }
}

Como alternativa, para fazer isso com o loop for, use isto;

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

Eu não vi a opção bool em outras respostas, então espero que o código abaixo ajude alguém.

Apenas use Any()

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

É possível combinar Any, Where, First e FirstOrDefault; ou apenas coloque o predicado em qualquer um desses métodos, dependendo do que for necessário.

Provavelmente, você deve evitar o uso do First, a menos que queira ter uma exceção lançada quando nenhuma correspondência for encontrada. FirstOrDefault geralmente é a melhor opção, desde que você saiba que retornará o padrão do tipo se nenhuma correspondência for encontrada (o padrão da string é nulo, int é 0, bool é 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" }

Teste este código em https://rextester.com/TXDL57489