Discussion :

[draco951]

Bonjour,

J'aimerai chargé une ObservableCollection avec plus de 200.000 record.

Le problème, c'est que ca prend du temps ... :-[

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
31
32
33
34
35
36
37
38
39
private ObservableCollection<ConfigMontage> ListAllDossier(String sDenomination)
{
	String sqltxt = null;
	ObservableCollection<ConfigMontage> lstCfMont = null;
	ConfigMontage cfMont = null;
 
	MySqlCommand myCmd = null;
	DataTable table = null;
	MySqlDataReader dataReader = null;
 
	try
	{
		db.OpenConnection();
 
		sqltxt = "SELECT * FROM deom.configgrue_viewalldossier WHERE sDenomination = @sDenomination";
		myCmd = new MySqlCommand(sqltxt, db.Connection);
		myCmd.Parameters.AddWithValue("@sDenomination", sDenomination);
		dataReader = myCmd.ExecuteReader();
		table = new DataTable();
		table.Load(dataReader);
		dataReader.Close();
 
		lstCfMont = new ObservableCollection<ConfigMontage>();
		foreach (DataRow row in table.Rows)
		{
			cfMont = new ConfigMontage()
				{
					NIdConfigMon = Convert.ToInt32(row["nIdDossierConfig"]),
				};
 
			lstCfMont.Add(cfMont);
		}
 
		return lstCfMont;
	}
	catch (Exception ex)
	{ throw ex; }
	finally
	{ db.CloseConnection(); }

Existe-t'il un moyen plus performant que celui ci pour charger des données ?

[Kikuts]

Bonjour, peux tu faire de la pagination ?

Quelle version du framework .NET utilises-tu ?

Ainsi tu pourrais utiliser les nouveautés de .NET 4.5 avec async await

[250rgv]

Une autre méthode ?

Pas utilisée avec ce volume de données mais c'est rapide à tester...

[draco951]

Bonjour,

Pagination ?
C'est à dire charger les données au fur et à mesure ?

J'utilise le framework 4.0

Mais je suppose que "async wait" permet de charger quelque chose en mémoire tout en pouvant faire autre chose ?

Pour ca, y a le backgroundworker qui fonctionne pas trop mal.

[Kikuts]

Non, ce que j'avais en tête était du chargement en parallèle (recherche task await async) par exemple envoyer 200 chargement de 1000 lignes.

Oui pour le chargement au fur et à mesure. Que veux tu faire de ces 200 k lignes ?

[draco951]

250Gr,
J'ai testé cette méthode et je trouve qu'elle n'ajoute rien en terme de performance (je l'ai testée)

Au final, je dois quand même bourré mes records dans une liste, et c'est la méthode de MyObservableCollection qui va charger les données.

Pourquoi 200. 000 ?
J'anticipe le futur :-)
Cela me permet d'afficher des dossier sauvegardé, et dès que tu dépasse les 5k, ca commence à ramer.
Mais au final, je dois quand même charger mes 200.000 record dans la mémoire.

Je vais jeter un oeil sur task await async

[youtpout978]

Déjà il faut savoir ce qui est le plus long la requête ou l'insertion des données dans ta list?
Tu peux utiliser la class StopWatch pour chronométrer le temps mis par chaque étape.
Pourquoi passes tu par une datatable? Tu peux directement crée un objet ConfigMontage depuis ton reader.
Tu peux aussi optimiser la requête en ajoutant des index aux bons endroit ou en passant par une procédure stockée (encore que sur une requête aussi simple), tu fais un select * alors que tu n'as besoin que d'un champ.

[draco951]

Pourquoi passes tu par une datatable? Tu peux directement crée un objet ConfigMontage depuis ton reader.

J'ai essayé par le dataReader, et ca me donne a quelque millisecondes prêt de meilleurs performance avec la datatable.

J'utiliserai quand même la méthode du datareader dorénavant :-)

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
select 
        `configgrue_dossierconfig`.`nIdDossierConfig` AS `nIdDossierConfig`,
        `configgrue_grue`.`sNomGrue` AS `sNomGrue`,
        `configgrue_dossierconfig`.`configgrue_Grue_nIdGrue` AS `nIdGrue`,
        `configgrue_dossierconfig`.`Reference` AS `Reference`,
        `configgrue_dossierconfig`.`IsTuning` AS `IsTuning`,
        `configgrue_dossierconfig`.`IsFeuilleCalcul` AS `IsFeuilleCalcul`,
        `configgrue_typemateriel`.`sTypeMateriel` AS `sTypeMateriel`,
        `configgrue_typemateriel`.`sDenomination` AS `sdenomination`,
        `configgrue_dossierconfig`.`entite_client_ID_Clients` AS `entite_client_ID_Clients`,
        `configgrue_dossierconfig`.`entite_client_ID_Clients_Facture` AS `entite_client_ID_Clients_Facture`,
        `configgrue_dossierconfig`.`entite_dealer_IDCon` AS `entite_dealer_IDCon`,
        `configgrue_dossierconfig`.`DateCreation` AS `DateCreation`,
        `configgrue_dossierconfig`.`DateModif` AS `DateModif`,
        `configgrue_dossierconfig`.`Numero` AS `Numero`
    from
        ((`configgrue_dossierconfig`
        left join `configgrue_grue` ON ((`configgrue_dossierconfig`.`configgrue_Grue_nIdGrue` = `configgrue_grue`.`nIdGrue`)))
        left join `configgrue_typemateriel` ON ((`configgrue_typemateriel`.`nIdTypeMateriel` = `configgrue_grue`.`configgrue_TypeMateriel_nIdTypeMateriel`)))

Ceci est ma requête (une vue stockée dans la DB), je l'ai simplifier ainsi que dans le code au possible.

L'exécution de la requête pour 12000 record prend 4.5 milliseconndes, c'est le chargement des données dans l'ObservableCollection qui prend une plombe (4.5 seconde).