Controlla se l'elenco contiene elementi che contengono una stringa e ottieni quell'elemento

Durante la ricerca di una risposta a questa domanda, mi sono imbattuto in altri simili utilizzando LINQ ma non sono stato in grado di comprenderli pienamente (e quindi implementarli), poiché non ne ho familiarità. Quello che vorrei, in sostanza, è questo:

1. Controlla se qualche elemento di un elenco contiene una stringa specifica.
2. In tal caso, ottieni quell'elemento.

Onestamente non so come farei per farlo. Quello che posso trovare è questo (non funziona, ovviamente):

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

So PERCHÉ non funziona:

• myList.Contains()non ritorna true, poiché verificherà se un intero elemento dell'elenco corrisponde alla stringa specificata.
• myList.IndexOf() non troverà una ricorrenza, poiché, come accade di nuovo, verificherà la presenza di un elemento corrispondente alla stringa.

Tuttavia, non ho idea di come risolvere questo problema, ma immagino che dovrò usare LINQ come suggerito in domande simili alle mie. Detto questo, se è il caso qui, vorrei che il rispondente mi spiegasse l'uso di LINQ nel loro esempio (come ho detto, non mi sono preoccupato ai miei tempi con C #). Grazie in anticipo ragazzi (e ragazze?).

EDIT: ho trovato una soluzione; basta scorrere l'elenco, verificare se l'elemento corrente contiene la stringa e quindi impostare una stringa uguale all'elemento corrente. Mi chiedo, però, esiste un modo più efficiente di questo?

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

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

Dovresti essere in grado di utilizzare Linq qui:

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

Se desideri semplicemente restituire il primo articolo corrispondente:

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

if(match != null)
    //Do stuff

La risposta di base è: è necessario scorrere ripetutamente il ciclo e verificare che qualsiasi elemento contenga la stringa specificata. Quindi, supponiamo che il codice sia:

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

Il codice equivalente, ma conciso, è:

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

Qui, x è un parametro che si comporta come "item" nel codice sopra.

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

I vecchi loop di moda sono quasi sempre i più veloci.

Se vuoi un elenco di stringhe contenenti la tua stringa:

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

Un'altra opzione è utilizzare Linq FirstOrDefault

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

Tieni presente che il Containsmetodo fa distinzione tra maiuscole e minuscole.

È possibile utilizzare il FirstOrDefaultmetodo di estensione Linq :

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

Ciò restituirà l'elemento pugno che contiene la sottostringa myStringo nullse non viene trovato tale elemento.

Se tutto ciò di cui hai bisogno è l'indice, usa il metodo List<T>della classe FindIndex:

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

Ciò restituirà l'indice dell'elemento pugno che contiene la sottostringa myStringo -1se non viene trovato tale elemento.

Molte buone risposte qui, ma ne uso una semplice usando Exists , come di seguito:

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

Dovresti essere in grado di usare qualcosa del genere, ha funzionato bene per me:

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

o qualcosa del genere, se hai bisogno di guardare dove non corrisponde.

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

Puoi usare

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

LINQ offre funzionalità per "interrogare" qualsiasi raccolta di dati. È possibile utilizzare la sintassi come una query di database (selezionare, dove, ecc.) In una raccolta (qui la raccolta (elenco) di stringhe).

quindi stai facendo come "prendimi elementi dall'elenco Dove soddisfa una determinata condizione"

all'interno del punto in cui stai utilizzando una "espressione lambda"

dire brevemente l'espressione lambda è qualcosa di simile (parametro di input => valore restituito)

quindi per un parametro "item", restituisce "item.Contains (" string richiesta ")". Quindi restituisce true se l'elemento contiene la stringa e quindi viene selezionato dall'elenco poiché ha soddisfatto la condizione.

Per semplicità, usa questo;

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

In alternativa, per fare ciò con for loop, usare questo;

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

Non ho visto l'opzione bool in altre risposte, quindi spero che sotto il codice possa aiutare qualcuno.

Basta usare Any()

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

È possibile combinare Any, Where, First e FirstOrDefault; o semplicemente posizionare il predicato in uno di questi metodi a seconda di ciò che è necessario.

Probabilmente dovresti evitare di usare First a meno che tu non voglia generare un'eccezione quando non viene trovata alcuna corrispondenza. FirstOrDefault è di solito l'opzione migliore fintanto che sai che restituirà l'impostazione predefinita del tipo se non viene trovata alcuna corrispondenza (l'impostazione predefinita della stringa è nulla, int è 0, valore bool è falso, ecc.).

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

Prova questo codice @ https://rextester.com/TXDL57489