Vérifier si la liste contient un élément qui contient une chaîne et obtenir cet élément.

Question

En cherchant une réponse à cette question, je suis tombé sur des questions similaires utilisant LINQ, mais je n'ai pas été en mesure de les comprendre pleinement (et donc de les mettre en œuvre), car je ne suis pas familiarisé avec ce système. Ce que je voudrais faire, en gros, c'est ceci :

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

Honnêtement, je ne sais pas comment je m'y prendrais pour faire ça. Ce que j'ai pu trouver, c'est ceci (qui ne fonctionne pas, bien sûr) :

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

Je sais pourquoi ça ne marche pas :

• myList.Contains() ne renvoie pas true car il vérifiera 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, puisque, comme c'est le cas à nouveau, il vérifiera un élément correspondant à la chaîne.

Pourtant, je n'ai aucune idée de la façon de résoudre ce problème, mais je me dis que je vais devoir utiliser LINQ comme suggéré dans des questions similaires à la mienne. Ceci étant dit, si c'est le cas ici, j'aimerais que la personne qui répond m'explique l'utilisation de LINQ dans son exemple (comme je l'ai dit, je ne m'en suis jamais occupé depuis que j'utilise C#). Merci d'avance les gars (et les filles ?).

EDIT : J'ai trouvé une solution ; il suffit de faire une boucle dans la liste, de vérifier si l'élément actuel contient la chaîne de caractères, puis de définir une chaîne de caractères égale à l'élément actuel. Je me demande cependant s'il existe une méthode plus efficace que celle-ci ?

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

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

Answer 1

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

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

Cela retournera le premier élément qui contient la sous-chaîne myString o null si aucun élément de ce type n'est trouvé.

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

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

Ceci retournera l'index du premier élément qui contient la sous-chaîne. myString o -1 si aucun élément de ce type n'est trouvé.

Answer 2

Beaucoup de bonnes réponses ici, mais j'en utilise une simple en utilisant Existe 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);
}

Answer 3

Vous devriez être en mesure d'utiliser quelque chose comme ça, cela a bien fonctionné pour moi :

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

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

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

Answer 4

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 cela avec la boucle for, utilisez ceci ;

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

Answer 5

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 offre la possibilité d'"interroger" n'importe quelle collection de données. Vous pouvez utiliser la syntaxe d'une requête de base de données (select, where, etc.) sur une collection (ici la collection (liste) de chaînes de caractères).

donc vous faites comme "obtenir les éléments de la liste où ils satisfont une condition donnée".

à l'intérieur du Where, vous utilisez une "expression lambda".

pour dire brièvement que 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("required string")" . Il retourne donc vrai si l'élément contient la chaîne de caractères et il est donc sélectionné dans la liste puisqu'il satisfait à la condition.