rechercher dans une List<Maclass> si une partie de MaClass est égale

Version imprimable

bonjour

Je cherche à tester ceci
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class Element { public int IDSuivi { get; set; } public int Avancement{ get; set; } } List<Element> ListElements = new List<Element>() ; a chaque reception { Element RetourRecu = new Element(); RetourRecu.IDSuivi = IDrecu ; RetourRecu.Avancement = Avancementrecu; // Y a t-il dans la liste "ListElements" un élément dont Element.IDsuivi = RetourRecu.IDSuivi }
Y a t-il dans la liste "ListElements" un élément dont Element.IDsuivi = RetourRecu.IDSuivi ?

J'arrive bien entendu à faire ca avec une vilaine boucle for mais je me dis qu'il y a surement bien plus joli...
Je pensais à List.contains au départ mais cela sous entend que je cherche à vérifier l'egalité sur "IDSuivi" et "Avancement" en même temps or je me fiche de Avancement dans cette recherche !

IDsuivi est une sorte d'index dans mon cas. Je cherche a me repositionner dans la liste pour mettre à jour Avancement justement.

Merci par avance pour vos lumières

28/02/2014, 13h03
PixelJuice

Salut,

avec Linq tu peux faire un truc du genre :

Code:

Element element = listElements.Find(ele => ele.IDsuivi == RetourRecu.IDSuivi);

Ca te retournera l'élément qui correspond a la condition.
28/02/2014, 14h09
Momoth

Bonjour,

Je te conseil également d'utiliser Linq. Après la méthode utilisée dépendra des différents cas qui peuvent arriver. Find() levera une exception si jamais aucun élément ne correspond a la restriction. Comme tu veux tester la présence d'un élément dans ta liste, je te conseil plus :

Code:

if (listElements.Where(ele => ele.IDsuivi == RetourRecu.IDsuivi).Count() > 0) {}

qui testera si il y'a des éléments dans ta liste qui ont cet ID.

Bonne journée.

-- Momoth --

La façon la plus efficace:
Code:

1 2 bool existe = maListe.Any(x => x.Property.Equals(maCondition));

Bonjour et merci pour les réponses, c'est effectivement bien plus beau qu'avec un for...

j'ai fait ceci (j'ai changé les noms pour les rendre plus en phase avec mon appli)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class TacheSuivi { public int IDtache { get; set; } public int AvancementTache { get; set; } } TacheSuivi RetourRecu = new TacheSuivi(); RetourRecu.IDtache = IdRecu ; RetourRecu.AvancementTache = AvancementRecu; if (ListAvancementTaches.Where(ele => ele.IDtache == RetourRecu.IDtache).Count() > 0) { TacheSuivi AvancementAmodifier = new TacheSuivi(); AvancementAmodifier = ListAvancementTaches.Where(ele => ele.IDtache == RetourRecu.IDtache).First() ; AvancementAmodifier.AvancementTache = RetourRecu.AvancementTache; } else { ListAvancementTaches.Add(RetourRecu); // il n'existe pas encore, ajout. }
Cela semble faire le job mais je m'inquiète juste de faire appel 2 fois au calcul de "ListAvancementTaches.Where(ele => ele.IDtache == RetourRecu.IDtache)"

peut mieux faire ?

Merci

28/02/2014, 15h16
petitours

Je précise que j'ai très peu de choses dans la liste
La plupart du temps il y en aura entre 1 et 4 et au grand maximum une 20n en gros

Je propose ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class TacheSuivi
{
 public int IDtache { get; set; }
 public int AvancementTache { get; set; }
}
 
TacheSuivi RetourRecu = new TacheSuivi();
RetourRecu.IDtache = IdRecu ;
RetourRecu.AvancementTache = AvancementRecu;

// >>>ICI<<<, pour ceux qui n'aurait pas bien lu, il y a qu'UN seul parcours de l'énumération
var AvancementAmodifier = ListAvancementTaches.FirstOrDefault(ele => ele.IDtache == RetourRecu.IDtache) ;
if (AvancementAmodifier != null)
{
 AvancementAmodifier.AvancementTache = RetourRecu.AvancementTache;
}
else 
{
  ListAvancementTaches.Add(RetourRecu); // il n'existe pas encore, ajout.
}

Peux mieux faire

Pour éviter de faire deux fois l'appel à la requête, une méthode consiste à récupérer dans une variable locale à la fonction le résultat et de vérifier si il est null ou pas ce qui donne ...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
            TacheSuivi locale = ListAvancementTaches.FirstOrDefault( x=> x.IDtache==RetourRecu.IDtache);
            if (locale != null)
            {
                TacheSuivi AvancementAmodifier = new TacheSuivi();
                AvancementAmodifier = ListAvancementTaches.Where(ele => ele.IDtache == RetourRecu.IDtache).First();
                AvancementAmodifier.AvancementTache = RetourRecu.AvancementTache;
            }
            else
            {
                ListAvancementTaches.Add(RetourRecu); // il n'existe pas encore, ajout.
            }

Même si il n'y a que quelques éléments dans la liste, ça vaudra le coup

28/02/2014, 15h54
petitours

punaise j'ai bien fait de poser la question !

J'ai appris pleins de choses

Merci
28/02/2014, 17h14
neilbgr

Sans vouloir faire le rabat-joie, même si en théorie pascalCH a raison, son code n'applique pas sa propre théorie (la variable "locale" est juste utilisée pour le teste, mais de nouveau un parcours de l'énumération est refaite (avec le where)).
Ceci dit, si vous lisez attentivement ce j'ai proposé, vous constaterez que l'énumération est réellement parcourue qu'une seule fois.