web-dev-qa-db-fra.com

Vérifie si list contient un élément contenant une chaîne et récupère cet élément

En cherchant une réponse à cette question, j'ai rencontré des exemples similaires utilisant LINQ, mais je n'ai pas été en mesure de les comprendre complètement (et donc de les mettre en œuvre), car je ne les connais pas bien. Ce que j'aimerais, en gros, c'est ceci:

  1. Vérifiez si un élément d'une liste contient une chaîne spécifique.
  2. Si c'est le cas, obtenez cet élément.

Honnêtement, je ne sais pas comment j'y arriverais. Ce que je peux trouver, c'est ceci (ne fonctionne pas, bien sûr):

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

Je sais POURQUOI cela ne fonctionne pas:

  • myList.Contains() ne renvoie pas true, car il vérifie si un élément entier de la liste correspond à la chaîne que j'ai spécifiée.
  • myList.IndexOf() ne trouvera pas d'occurrence car, comme c'est encore le cas, elle recherchera un élément correspondant à la chaîne.

Pourtant, je ne sais pas comment résoudre ce problème, mais je suppose que je devrai utiliser LINQ comme suggéré dans des questions similaires aux miennes. Cela étant dit, si tel est le cas ici, j'aimerais que le répondeur m'explique l'utilisation de LINQ dans son exemple (comme je l'ai dit, cela ne me dérangeait pas depuis que je travaillais avec C #). Merci d'avance les gars (et les filles?).

EDIT: J'ai trouvé une solution. parcourez la liste, vérifiez si l’élément actuel contient la chaîne, puis définissez une chaîne égale à l’élément actuel. Je me demande cependant s'il existe un moyen plus efficace que cela.

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

for (int i = 0; i < myList.Count; i++)
{
    if (myList[i].Contains(myString))
        element = myList[i];
}
c#.netlinqlistcontains
116
Dimitris Iliadis

Vous devriez pouvoir utiliser Linq ici:

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

Si vous souhaitez simplement retourner le premier article correspondant:

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

if(match != null)
    //Do stuff
169
Dave Bish

La réponse de base est la suivante: vous devez parcourir la boucle et vérifier que tout élément contient la chaîne spécifiée. Donc, disons que le code est:

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

Le code équivalent, mais concis, est le suivant:

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

Ici, x est un paramètre qui agit comme "item" dans le code ci-dessus.

26
userda
string result = myList.FirstOrDefault(x => x == myString)
if(result != null)
{
  //found
}
12
Chris
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;
    }
}

Les boucles à l'ancienne sont presque toujours les plus rapides.

9
McKay

Si vous voulez une liste de chaînes contenant votre chaîne:

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

Une autre option consiste à utiliser Linq FirstOrDefault

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

Gardez à l'esprit que la méthode Contains est sensible à la casse.

4
Alessandro D'Andria

Vous pouvez utiliser la méthode d'extension de Linq FirstOrDefault :

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

Cela renverra le premier élément contenant la sous-chaîne myString ou null si aucun élément de ce type n'est trouvé.

Si vous avez seulement besoin de l'index, utilisez la méthode FindIndex de la classe List<T>:

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

Ceci renverra l'index du premier élément contenant la sous-chaîne myString ou -1 si aucun élément de ce type n'est trouvé.

2
p.s.w.g

Vous devriez pouvoir utiliser quelque chose comme ça, ça a fonctionné pour moi:

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

ou quelque chose comme ça, si vous avez besoin de regarder où cela ne correspond pas.

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

vous pouvez utiliser

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

LINQ vous fournit des fonctionnalités pour "interroger" toute collection de données. Vous pouvez utiliser la syntaxe comme une requête de base de données (select, where, etc.) sur une collection (ici la collection (liste) de chaînes).

de sorte que vous faites comme "me chercher des éléments de la liste où il satisfait à une condition donnée"

à l'intérieur de l'endroit où vous utilisez une "expression lambda"

dire brièvement l'expression lambda est quelque chose comme (paramètre d'entrée => valeur de retour)

donc pour un paramètre "item", il retourne "item.Contains (" chaîne requise ")". Donc, il renvoie true si l'élément contient la chaîne, ce qui lui permet d'être sélectionné dans la liste car il remplit la condition.

1
Nithin Nayagam

Beaucoup de bonnes réponses ici, mais j’en utilise une simple en utilisant Exists, comme ci-dessous:

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

Pour rester simple, utilisez ceci;

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

Alternativement, pour faire ceci avec la boucle for, utilisez ceci;

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

Je n'ai pas vu l'option bool dans d'autres réponses donc j'espère que le code ci-dessous aidera quelqu'un.

Il suffit d'utiliser Any()

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