Discussion :

[stailer]

Bonjour tout le monde,

Mon problème sur les ArrayList est au niveau de la recherche et de la suppression.

Par exemple j'ai un ArrayList qui s'appelle ligne
et j'ai une classe objet qui s'appelle Trace

Alors pour accèder à chaque ligne je fais ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for (int x = 0 ; x < ligne.Count ; x++)
{
     Trace mytrace = (Trace)ligne[x];     
}

Et à priori ca fonctionne.... Mais voila, comment supprimer un élément sur cette boucle ? car si j'efface un élément de ligne la boucle ne sera plus valide... De plus, y a t - il un moyen de faire une recherche d'un élément précis sans passer par une boucle... j'ai trouvé IComparer
mais c'est pour trier, pas pour rechercher.

Voila, merci de votre aide, pour cette question pas facile facile..

[crjo]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
foreach (Trace mytrace in ligne)
{
  // utiliser l'élément courant
  mytrace.fonctionMembre();
 
  // supprimer l'élément suivant un critère 'MustBeRemoved'
  if (mytrace.MustBeRemoved)  
    ligne.Remove(mytrace);
}

J'ai pas l'occasion de tester le code donné, mais je pense que ça devrait fonctionner pour parcourir un ArrayList et supprimer certains éléments.

A vérifier donc.

Sinon, pour rechercher un élément dans une liste, intéresse toi à

ArrayList.IndexOf(Object) et ArrayList.LastIndexOf(Object)

[stailer]

salut,

merci pour ta réponse... Mais à priori le problème est le même.
Ca enlève bien l'élément de la liste, mais au tour suivant de la boucle, ca devient invalide et j'ai une erreur :

La collection a été modifiée*; l'opération d'énumération peut ne pas s'exécuter.

... En fait cet arraylist stocke des lignes tracées à l'écran. Je voudrais recalculer uniquement les lignes que l'utilisateur a modifié, et pour l'instant la seule solution que j'ai trouvé est de détruire complètement l'arraylist et le reconstruire.
Alors ca va si il y a 50 lignes... Mais si il y en a 1000...
Enfin bon, ca c'est juste pour info.

[crjo]

j'ai pu tester le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int idx;
ArrayList al = new ArrayList(10);
 
// crée 10 éléments string dans al : A B C ...
char c = 'A';
for (idx=0; idx<15; idx++)
{
    string str = c.ToString();
    al.Add(str);
    c++;
}
 
// supprime l'élément "H". On cherche l'index et on supprime l'élément à cet index
idx = al.IndexOf("H");
al.RemoveAt(idx);
 
// supprime l'élément "D" d'une autre manière, que je déconseille
for (idx=0; idx<al.Count; idx++)
{
    string str = (string)al[idx];
 
    if (str == "D")
        al.RemoveAt(idx);
}

Ce code fonctionne bien pour moi.

Mais le coup de la boucle for, c'est très foireux si tu dois faire plusieurs suppressions. Le problème, c'est que lorsque un élément est supprimé, idx va quand même être incrémenté, et donc, l'élément qui suivait ne va pas être traité par le corps de la boucle.

Pour te convaincre, essaie ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
for (idx=0; idx<al.Count; idx++)
{
    string str = (string)al[idx];
 
    if (str == "D" || str == "E")
        al.RemoveAt(idx);
}

et tu verras que l'élément "E" n'est pas supprimé.

Pour éviter cela, tu peux faire ta boucle à l'envers :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (idx=al.Count-1; idx>=0; idx--)

Si tu dois absolument les regarder dans l'ordre croissant, essaie une boucle while

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
int idx=0;
while(true)
{
    string str = (string)al[idx];
 
    if (str == "D" || str == "E")
    {
        al.RemoveAt(idx);
        continue;  // recommence la boucle sans incrément idx
    }
 
    idx++;
}

Alors, c'était ça ?

[stailer]

Oooook j'ai compris... Je savais pas qu'il fallait utiliser le IndexOf de cette manière.

Merci beaucoup pour toutes ces explications, maintenant ca fonctionne impec.

A+ !