Discussion :

[Nip]

Bonjour a tous,

j'ai une collection que je conserve en cache dans mon appli, ca m'evite d'aller reinterroger ma BD embarquee.
Cette collection contient des noms d'organismes (avec tous les parametres associes):je dois verifier parmi les differentes adresses de ces organismes (donc une autre collection) lesquelles appartiennent a une region donnee (identifiee par identifiantRegion._id).
J'ai donc les classes suivantes: organisme, adresse, ville, departement et region.

Voila le code que j'utilise

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
foreach(IOrganisme iorganisme in CollectionOrganismes)
{	
	foreach (IAdresse iadresse in iorganisme._adresseCollection)
	{
		if (iadresse._ville._departement._region._id.Equals(identifiantRegion._id))
			{
				ListViewItem lvi = new ListViewItem();
				lvi.Tag = iorga;
				lvi.Text = iorga._nom ;
				MaListViewAMoi.Items.Add(lvi);
			}
 
	}
}

Les performances sont bien evidemment desastreuses, mais je ne vois pas comment faire autrement qu'en passant par ces boucles imbriquees. Voyez vous un moyen d'ameliorer tout ca?

[HULK]

bah tu peux pas refaire une requete sur ta base ???

[Nip]

bah tu peux pas refaire une requete sur ta base ???

Si bien sur, et c'etait la ma premiere facon de faire; mais les performances ne sont pas au rendez vous; je travaille sur une base cryptee, la decrypter prend du temps et c'est pour cette raison que je voulais effectuer ma recherche sur les donnees deja sortie et presente en cache.

[Merlin]

Les performances sont bien evidemment desastreuses, mais je ne vois pas comment faire autrement qu'en passant par ces boucles imbriquees. Voyez vous un moyen d'ameliorer tout ca?

tout dépend de la longueur de tes listes, mais il est clair que le traitement peu être long.
Ce bon Niklaus Wirth, père du Pascal, nous a enseigné dans son ouvrage "Algorithms + Data Structures = Programs" une chose essentielle : les structures de données sont aussi importantes que les algos...
Et dans le cas de ta recherche, à la fois l'algo et la structure de données ne sont pas adaptées tout simplement :-)

Si tes listes sont grandes, ce qui semble être le cas si tu parles de traitements longs, plutôt que des collections d'interfaces, il serait plus sage d'utiliser des listes hashées sur le champ ID comme clé par exemple.
Ou tout autre structure clé/valeur utilisant un système de tri et une recherche dichotomique ou un arbre binaire.
Ta recherche deviendra instantanée...

[Nip]

Mes collections ne sont pas si importantes puisque pour cet exemple il y a seulement 2000 valeurs. Mais la ligne

Code :

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

if (iadresse._ville._departement._region._id.Equals(identifiantRegion._id))

prend reellement beaucoup de temps; de toute facon meme sans cette ligne les 2 foreach imbriques entrainent un traitement trop long

Je vais regarder du cote des listes hashees et je vous tiens au courant, merci Merlin

[DrQ]

Qu'appelles tu prendre du temps ?? J'utilise des algos avec environ 2000 lignes qui en moins d'une seconde filtre et tri le résultat souhaité et ce toutes les secondes et avec rafraichissement de l'UI.
Donc je suis surpris que ça soit si long que ça !!!
Est ce que tes collections évoluent ? Si oui peuvent elles évoluées pendant leur parcours ? Fais tu des lock sur tes collections ?

Pour des raisons de perfs pures, un for simple sera peut être un peu plus adéquat.

[Nip]

Qu'appelles tu prendre du temps ?? J'utilise des algos avec environ 2000 lignes qui en moins d'une seconde filtre et tri le résultat souhaité et ce toutes les secondes et avec rafraichissement de l'UI.

Je parle de 1 seconde pour la simple manipulation de la liste (juste apres le premier foreach) mais de plus de 2 minutes des le passage dans le deuxieme foreach(c'est le point critique) et pres de 4 minutes en executant la sequence complete.

Est ce que tes collections évoluent ? Si oui peuvent elles évoluées pendant leur parcours ? Fais tu des lock sur tes collections ?

mes collections ne bougent pas et sont tirees de mon singleton

[Wyatan]

Quelques pistes :

• Teste ce code:

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  foreach(IOrganisme iorganisme in CollectionOrganismes) 
  {    
     foreach (IAdresse iadresse in iorganisme._adresseCollection) 
     { 
        if (iadresse._ville._departement._region._id.Equals(identifiantRegion._id)) 
           { 
              ListViewItem lvi = new ListViewItem(); 
              lvi.Tag = iorga; 
              lvi.Text = iorga._nom ; 
              // MaListViewAMoi.Items.Add(lvi); 
           } 
   
     } 
  }

  Si le traitement est beaucoup plus rapide, alors c'est le peuplement de ta ListView qui est en cause. Je te conseille dans ce cas de jeter un oeil à la section "Control Population" de cet article.
• Plutôt qu'utiliser des foreach dont certes la syntaxe est sympathique, implémente des IEnumerators. Si mes souvenirs sont exacts, sous le framework 1.1 les énumérateurs utilisés par l'instruction foreach sont des classes au lieu d'être des struct, ce qui a un impact négatif sur les performances.
• Est-ce que tes ID sont des entiers ? Si ce sont des strings, alors tu devrais t'efforcer d'utiliser des entiers (la comparaison est bcp plus rapide).

[Nip]

Salut Wyatan, merci pour tes remarques

Si le traitement est beaucoup plus rapide, alors c'est le peuplement de ta ListView qui est en cause. Je te conseille dans ce cas de jeter un oeil à la section "Control Population" de cet article.

Aucune difference de performances a ce niveau; mais je n'avais pas lu l'article, tres instructif

Plutôt qu'utiliser des foreach dont certes la syntaxe est sympathique, implémente des IEnumerators. Si mes souvenirs sont exacts, sous le framework 1.1 les énumérateurs utilisés par l'instruction foreach sont des classes au lieu d'être des struct, ce qui a un impact négatif sur les performances.

Je vais reagrder aussi de ce cote, merci

Est-ce que tes ID sont des entiers ? Si ce sont des strings, alors tu devrais t'efforcer d'utiliser des entiers (la comparaison est bcp plus rapide).

De ce cote, malheureusement, je n'y touche pas, les ID sont des GUID et pris en charge par mon outil de mapping OR.

[Wyatan]

Une autre piste pourrait être de rendre ton modèle de données moins "puriste", justement pour des raisons de performances : intègre à chaque adresse directement les identifiants du département et de la région à laquelle elle appartient.

Au fait, si un organisme dispose de plusieurs adresses dans une même région, il apparaîtra plusieurs fois dans ta liste. Ne devrais-tu pas ajouter un break à la fin de ton bloc conditionnel pour éviter ces doublons (et quelques boucles inutiles) ?

[joujoukinder]

Tu pourrrais peut-être modifier ton code afin de mettre tes éléments dans une table de hashage...

[DrQ]

Cela prendrait un peu plus de mémoire, mais ne serait pas plus d'avoir tes à plat en mémoire (résultat d'une requête avec les jointures entre toutes les tables) ?

Si c'est l'utilisation mémoire que tu ne veux pas trop utilsé (même si tu fais 2000 lignes * 1024 octets (tout confondu), ça ne fait que 2Mo de données en mémoire), tu peux construire tes objets différemment.

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
25
26
27
28
29
30
 
public class Address
{
  private string _strAddress1;
  private string _strAddress2;
  private string _strCity;
  private string _strCodePostal;
  ...
}
 
public class Organisme
{
  // Liste des adresses
  private ArrayList _oArrayListAddresses = null;
  // Adresse par défaut
  Address _oAddressDefault = null;
  // Nom de l'organisme
  private string _strName;
 
 
  public void AddAddress(Address oAddress)
  {
    _oArrayListAddresses.Add(oAddress);
  }
 
  public void SetDefaultAddress(Address oAddress)
  {
    _oAddressDefault = oAddress;
  }
}

Biensûr après faut créer les accesseurs nécessaires.
Si en mémoire tu stockes déjà de cette façon tu gagneras un temps conséquent.

Rien ne t'empêche d'avoir une collection d'adresses, de ville, de région séparées, mais en mémoire de toute façon ce sont des pointeurs que tu auras sauf si tu souhaites garder la donnée indépendemment de tes collections dans quel tu devras faire une copie de tes objets.

[Nip]

Voila j'ai pu travailler dessus hier et ca marche niquel .
J'ai fait le choix de la hashtable et je dois avouer que les perfs sont extremements satisfaisantes: 2 secondes au lieu des 4 minutes precedemments annoncees.
Par ailleurs je me suis servi de Build a C# DictionaryHashList Collection Object qui me permet de gerer mes collections d'objet de facon efficace.

Je n'ai pas eu le temps de regarder ta solution DrQ, mais je ne veux pas toucher a mes classes. Peut etre en modifiant les interfaces, je regarderai plus tard, merci.

Maintenant un autre probleme se pose puisque mon appli mets pres de 3 minutes a se lancer, le temps de peupler ma Hashtable. Je regarde ca et si je ne peux pas le resoudre je reviens vers vous.
Ce probleme est resolu, merci.