Discussion :

[Jean-Marc68]

Salut,

Soit une tâche statique "public static async Task<ObservableCollection<Pt>> ImportPointAsync(int srid, string mdbPath, IProgress<int> progress)"
Cette tâche crée des points suite à la lecture de 2 tables.
Comment fonctionne-t-elle actuellement ? Elle commence par charger les tables dans 2 DataTables puis, ligne par ligne, crée les points.
La tâche fonctionne, mais vous comprenez que créer un par un plus de 60 000 point prend un peu de temps.
Voici la partie de code qui m'intéresse (que je voudrais améliorer) :

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
            ObservableCollection<Pt> points = new ObservableCollection<Pt>();
            int totalCount = dtPoints.Rows.Count;
            int processCount = await Task.Run<int>(() =>
            {
                int count = 0;
                foreach (DataRow drPoint in dtPoints.Rows)
                {
                    if (drPoint != null)
                    {
                        DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                        List<int> lstPCodes = new List<int>();
                        foreach (DataRow drPCode in drsPCodes)
                        {
                            int pcode = 0;
                            if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                                lstPCodes.Add(pcode);
                        }
                        Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                        if (newPoint != null && !points.Contains(newPoint))
                            points.Add(newPoint);
                    }
                    if (progress != null)
                    {
                        progress.Report((count * 100 / totalCount));
                    }
                    count++;
                }
 
 
                return count;
            });
            if (points != null && points.Count > 0)
                return points;
            return null;

Que voudrais-je faire ? Paralléliser la création de points, mais c'est là que je coince depuis plusieurs jours et donc que je fais appel à vous.

J'avais pensé à faire une liste des taches dont chaque tâche créerait 1000 points. Si déterminer les index de départ et de fin de lecture pour chaque tâche parallèle ne pose pas de problème (mais est-ce vraiment la meilleure solution ?), je voudrais que la tâche de base (ImportPointAsync) retourne la progression globale (en calculant le nombre de points créés en fonction du nombre de points que chaque tâche devrait retourner (comment faire cela et le gérer ?) et du total des lignes de la table dtpoints).

Merci de vos z'avis z'avisés.

[ZenZiTone]

Bonjour,

Je ne m'y connais pas trop en parallélisme et tout, donc je prend le problème différemment : à quoi servent ces 60k points?

Si c'est pour de l'affichage on peut considérer que l’entièreté des points n'est pas nécessaire tout de suite (on peu donc charger les points en arrière plant et rafraîchir régulièrement l'affichage)

[Jean-Marc68]

Malheureusement non. Ils ne seront pas affichés mais doivent tous être créés car ils forment des polygones qui doivent être vérifiés.
Merci quand-même de l'intérêt que tu portes à mon problème.

[theMonz31]

Salut

la solution de découper en plusieurs sous tache est une bonne idée

pour la progression, regarde ce thread : http://stackoverflow.com/questions/1...rallel-foreach

et sinon, tu peux surement améliorer en évitant quelques "erreurs"

Si tu connais la taille de ta liste, tu peux dès la création de ta liste qui contiendra les données lui donner sa taille (genre new List(60000);
tu gagneras du temps d'allocation mémoire pour commencer

ensuite, tu fais souvent dans ton code : points.contains() ==> Ca coute cher aussi ça.. je peux comprendre que tu veuilles éviter d'éventuelle doublon, mais à ce moment
là, peut-être qu'un dictionary et ou une table de hash te fera aussi gagner du temps

[Jean-Marc68]

Merci beaucoup theMonz31,
J'avais trouvé "tout seul comme un grand" que les contains ralentissaient beaucoup.
En les enlevant et en remplaçant le return par un Distinct de la list à retourner, je me suis rendu compte que je passais de 44 sec à ... 5.6 sec !!
Par contre je ne savais pas que j'accélérerais en créant les listes avec leur taille finale (si connue bien entendu, mais dans ce cas ci c'est connu), et je ne connaissais pas du tout le Parallel.ForEach que j'avais donc "réinventé" (mais en moins bien évidemment). Grâce au Parallel.ForEach dans un await Task.Run, j'ai aussi pu gérer la progression.

Pour ceux que cela intéressent, voici le code modifié suite aux précieux conseils de theMonz31 (Je vous fais grâce du début de la méthode qui charge la BDD dans des DataTables. Ce n'est pas l'objet de ma question de départ et j'imagine que tout le monde sait le faire)

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
            if (dtPoints == null || dtPoints.Rows.Count == 0 || dtPCodes == null || dtPCodes.Rows.Count == 0)                return null;
            List<Pt> points = new List<Pt>(dtPoints.Rows.Count);
            int totalCount = dtPoints.Rows.Count, count = 1;
            Object obj = new Object();
            await Task.Run (() => 
                Parallel.ForEach(dtPoints.AsEnumerable(), (drPoint) =>
                    {
                        if (drPoint != null)
                        {
                            DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                            List<int> lstPCodes = new List<int>();
                            foreach (DataRow drPCode in drsPCodes)
                            {
                                int pcode = 0;
                                if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                                    lstPCodes.Add(pcode);
                            }
                            Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                            if (newPoint != null)
                                points.Add(newPoint);
                        }
                        lock (obj)
                        {
                            if (progress != null)
                            {
                                count++;
                                progress.Report((count * 100 / totalCount));
                            }
                        }
                    })
                );
            if (points != null && points.Count > 0)
                return new ObservableCollection<Pt>(points.Distinct());
            return null;

[Noxen]

Par contre je ne savais pas que j'accélérerais en créant les listes avec leur taille finale (si connue bien entendu, mais dans ce cas ci c'est connu)

Les conteneurs dynamiques comme les List gèrent souvent une taille (le nombre d'objets stockés) et une capacité (le nombre d'emplacements disponibles). Quand on veut ajouter un objet alors que la taille atteint déjà la capacité le conteneur, pour s'adapter, va réserver une nouvelle zone mémoire plus grande (généralement le double), recopier la première zone mémoire, la libérer, puis ajouter le nouvel item sur cette nouvelle zone. Si tu connais à l'avance le nombre d'objets à contenir tu peux demander à ta List de réserver directement la capacité dont elle a besoin et éviter cette effet de dépassement de seuil.

[dzediar]

Tu devrais utiliser System.Threading.Tasks.Parallel.ForEach() en passant à ce ForEach une liste d'étendues de points à calculer.

Par contre rafraichi l'IHM en appelant Dispatcher.BeginInvoke() ou Dispatcher.Invoke() pour ne pas avoir de problème.

[Jean-Marc68]

Merci Noxen,
C'est toujours intéressant d'apprendre le pourquoi du comment. Ça permet après de savoir comment, mais surtout pourquoi faire autrement.

[Jean-Marc68]

Dzedia, je ne comprend pas très bien ce que tu veux dire par "Tu devrais utiliser System.Threading.Tasks.Parallel.ForEach() en passant à ce ForEach une liste d'étendues de points à calculer."
En ce qui concerne la modification de l'IHM, je retourne un IProgress car cette méthode se situe dans une bibliothèque que je suis en train de créer.
L'IHM qui consommera la bibliothèque pourra donc gérer la progression retournée par l'IProgress comme elle l'entend (si j'ai bien compris ce que tu voulais dire à propos de l'invocation).

[dzediar]

https://msdn.microsoft.com/fr-fr/lib...v=vs.110).aspx

[Jean-Marc68]

J'ai lu cette page mais je ne comprend pas ce que je fais mal (et donc pourquoi je le fais mal, et donc comment le corriger). Est-ce la ligne Parallel.ForEach(dtPoints.AsEnumerable(), (drPoint) => qui n'est pas correcte ?
Aussi, si je peux utiliser l'invocation dans la bibliothèque, comment dois-je faire ?
J'ai modifié mon code comme ceci, mais les 2 await successif me laissent douter que mon code n'est pas correct.
De plus, avec la ligne "await System.Windows.Application.Current.Dispatcher.Invoke(async () =>", le code compile mais ne passe plus, j'ai une erreur :
"Une exception de type 'System.NullReferenceException' s'est produite dans mscorlib.dll mais n'a pas été gérée dans le code utilisateur
Informations supplémentaires : La référence d'objet n'est pas définie à une instance d'un objet."
Ça me confirme bien qu'il y a un pbl, mais je ne trouve toutefois pas la solution idéale avec l'invocation.
Mais est-ce vraiment nécessaire dans une méthode de type "public static async Task<ObservableCollection<Pt>> ImportPointAsync(int srid, string mdbPath, IProgress<int> progress)" ?

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
40
            if (dtPoints == null || dtPoints.Rows.Count == 0 || dtPCodes == null || dtPCodes.Rows.Count == 0)
                return null;
            List<Pt> points = new List<Pt>(dtPoints.Rows.Count);
            int totalCount = dtPoints.Rows.Count, count = 1;
            Object obj = new Object();
            await System.Windows.Application.Current.Dispatcher.Invoke(async () =>
            {
               await Task.Run(() =>
               Parallel.ForEach(dtPoints.AsEnumerable(), (drPoint) =>
                   {
                       // The more computational work you do here, the greater 
                       // the speedup compared to a sequential foreach loop.
                       if (drPoint != null)
                       {
                           DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                           List<int> lstPCodes = new List<int>();
                           foreach (DataRow drPCode in drsPCodes)
                           {
                               int pcode = 0;
                               if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                                   lstPCodes.Add(pcode);
                           }
                           Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                           if (newPoint != null)
                               points.Add(newPoint);
                       }
                       lock (obj)
                       {
                           if (progress != null)
                           {
                               count++;
                               progress.Report((count * 100 / totalCount));
                           }
                       }
                   })
                );
            });
            if (points != null && points.Count > 0)
                return new ObservableCollection<Pt>(points.Distinct());
            return null;

[Noxen]

Dispatcher.Invoke permet dans une application fenêtrée d'accéder au thread de l'interface depuis un autre thread (sinon la compartimentation des thread provoquerait une exception). Mais l'usage d'async/await fait que le compilateur prend en charge pas mal de choses. Je n'ai pas tous les détails en tête, il me faudrait relire les différents articles sur le sujet. François Dorin est le spécialiste du sujet sur developpez.com, il pourra clarifier les choses s'il passe sur ce fil de discussion et qu'il a le temps.

[nouanda]

J'espère ne pas dire de bêtise, mais je crois bien que les objets List<T> ne sont pas thread-safe (en fait, j'en suis sûr).
La commande points.Add(newPoint); va subir une race condition entre les threads générés par le Parallel.ForEach, et il y a un risque de ne pas retourner les bonnes valeurs. Et comme c'est la base du retour de ta fonction, autant le signaler.
Il vaut mieux se tourner vers un ImmutableList<T>, qui est thread-safe, ou implémenter une gestion de la synchronisation (Immutable, c'est bien...)

Et en ayant dit cela, je n'aide pas sur le progress, mais je sauve peut-être certaines de tes données...

[dzediar]

En plus de ce qui est dit plus haut :

A mon avis le Task.Run est en trop. Le Parallel.Foreach() n'en a pas besoin.

Ensuite Dispatcher.Invoke doit être appelé directement sans await. Il permet de mettre à jour l'affichage dans le thread d'affichage justement, et non dans le thread créé par Parallel.Foreach().

Si tu veux attendre la fin de la maj de l'affichage (du point), appels Dispatcher.Invoke. En revanche si tu n'a pas besoin d'attendre la fin de l'affichage du point, appels Dispatcher.BeginInvoke (version asynchrone de Invoke).

Ça devrait donner un truc comme ça :

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
            List<Pt> points = new List<Pt>(dtPoints.Rows.Count);
            int totalCount = dtPoints.Rows.Count, count = 1;
 
            System.Threading.Tasks.Parallel.ForEach(dtPoints.Rows.OfType<System.Data.DataRow>().ToList(), (drPoint) =>
            {
                // The more computational work you do here, the greater 
                // the speedup compared to a sequential foreach loop.
                if (drPoint != null)
                {
                    System.Data.DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                    List<int> lstPCodes = new List<int>();
                    foreach (System.Data.DataRow drPCode in drsPCodes)
                    {
                        int pcode = 0;
                        if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                            lstPCodes.Add(pcode);
                    }
                    Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                    if (newPoint != null)
                        lock(points)
                            points.Add(newPoint);
                }
 
                System.Windows.Application.Current.Dispatcher.BeginInvoke(() =>
                {
                    if (progress != null)
                    {
                        count++;
                        progress.Report((count * 100 / totalCount));
 
                        // Afficher le point ici 
                    }
                });
            });
            if (points != null && points.Count > 0)
                return new ObservableCollection<Pt>(points.Distinct());
            return null;

en outre je te conseille de passer des listes de points à traiter à Parallel.Foreach() plutôt qu'un point à la fois. Tu peux aussi limiter le nb de tâches en parallel pour éviter de surcharger la machine :

int i = 0;
var maListeDeListesDePoints = dtPoints.Rows.OfType<System.Data.DataRow>().GroupBy(x => i++ / 5).Select(x => x.ToList()).ToList(); // Constitue des listes de 5 points
Parallel.ForEach(maListeDeListesDePoints, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount / 2 }, listeDePoints => { ....

[Jean-Marc68]

Merci à tous pour vos différentes aides qui m'aident, mais surtout qui m'apprennent beaucoup.
Vos explications sont tellement plus parlantes pour moi que ce que je trouve sur les sites "généraux".

A mon avis le Task.Run est en trop. Le Parallel.Foreach() n'en a pas besoin.

Je ne sais pas si c'est la meilleure façon de faire, mais j'ai mis le Task.Run car la méthode est un async Task qui doit retourner, entre autre, une progression.
En effet le Parallel.Foreach() n'a pas besoin de Task.Run, mais pour pouvoir retourner la progression après chaque itération du Parallel.Foreach(), il faut que le Parallel.Foreach() soit dans un await afin que la progression puisse être retournée après chaque itération et pas après le Parallel.Foreach() complet.

Le invoke ou begininvoke ne me paraît pas utile dans le cas présent parce que je ne change rien dans le Threat de l'UI. Comme cette méthode doit se trouver dans une bibliothèque, je ne sais pas a priori comment sera gérée la progression (le nom de la progressbar à alimenter peut être différent dans différents projets faisant appel à la bibliothèque, par exemple). Il n'y a donc pas d'affichage de point, ou de texte ou quoi que ce soit d'autre. Je retourne juste une progression et l'appelant gère la progression comme il le veut. Je ne fais donc que lui retourner une progression de l'avancée de la création des points (qui est gérée par l'UI appelante), puis la liste des points à la fin. Actuellement sur un projet test, la ProgressBar avance bien au fur et à mesure de la création des points.

J'espère ne pas dire de bêtise, mais je crois bien que les objets List<T> ne sont pas thread-safe (en fait, j'en suis sûr).
La commande points.Add(newPoint); va subir une race condition entre les threads générés par le Parallel.ForEach, et il y a un risque de ne pas retourner les bonnes valeurs. Et comme c'est la base du retour de ta fonction, autant le signaler.
Il vaut mieux se tourner vers un ImmutableList<T>, qui est thread-safe, ou implémenter une gestion de la synchronisation (Immutable, c'est bien...)

Je ne connaissais pas le ImmutableList que j'ai installé (Nuget). Par contre new ImmutableList<T>(int longueurDeLaListe) ne semble pas exister. J'ai dont bricolé

Code :

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

ImmutableList<Pt> points = new List<Pt>(dtPoints.Rows.Count).ToImmutableList();

qui ne me semble pas très propre visuellement mais qui a l'air de fonctionner.
Je me doutait que je pouvais avoir des problèmes avec l'alimentation de ma List, c'est pourquoi j'avais fais

Code :

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

1
2
3
4
5
6
7
                           if (newPoint != null)
                           {
                               lock (obj)
                               {
                                   points.Add(newPoint);
                               }
                           }

car je me disais qu'en "lockant" la liste, elle ne pourrait pas être alimentée par 2 Threat en même temps, mais que les Threat devraient attendre leur tour. Peut-être étais-je dans l'erreur ou, ce à quoi je pensais, ça ralenti l'alimentation de la liste si des Threat doivent attendre.

En conclusion, encore merci à tous de votre aide et de vos explications.
La situation actuelle de la méthode est

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
40
41
42
43
44
45
        public static async Task<ObservableCollection<Pt>> ImportPointAsync(int srid, string mdbPath, IProgress<int> progress)
        {
            DataTable dtPoints = new DataTable();
            DataTable dtPCodes = new DataTable();
 
            --- chargement des tables à partir de la mdb ---
 
            if (dtPoints == null || dtPoints.Rows.Count == 0 || dtPCodes == null || dtPCodes.Rows.Count == 0)
                return null;
            ImmutableList<Pt> points = new List<Pt>(dtPoints.Rows.Count).ToImmutableList();
            int totalCount = 0, count = 1, i=0;
            Object obj = new Object();
            var maListeDeListesDePoints = dtPoints.Rows.OfType<System.Data.DataRow>().GroupBy(x => i++ / 5).Select(x => x.ToList()).ToList(); // Constitue des listes de 5 points
            totalCount = maListeDeListesDePoints.Count;
            await Task.Run(() =>
            Parallel.ForEach(maListeDeListesDePoints, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount / 2 }, listeDePoints => {
                       for (int j=0; j< listeDePoints.Count; j++)
                       {
                           DataRow drPoint = listeDePoints[j];
                           DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                           List<int> lstPCodes = new List<int>();
                           foreach (DataRow drPCode in drsPCodes)
                           {
                               int pcode = 0;
                               if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                                   lstPCodes.Add(pcode);
                           }
                           Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                           if (newPoint != null)
                            points.Add(newPoint);
                       }
                       lock (obj)
                       {
                           if (progress != null)
                           {
                               count++;
                               progress.Report((count * 100 / totalCount));
                           }
                       }
                   })
                );
            if (points != null && points.Count > 0)
                return new ObservableCollection<Pt>(points.Distinct());
            return null;
        }

[Noxen]

Au regard de la description de ImmutableList<T> dans la msdn je suis un peu perplexe dans son usage. Est-ce-que au lieu de points.Add(newPoint); ça ne devrait pas être points = points.Add(newPoint); ? Tu obtiens bien le résultat attendu ?

[Jean-Marc68]

Merci de cette très juste observation, Noxen. Je corrige.

[Noxen]

Ok, je prendrai le temps de décortiquer la fonction pour bien comprendre.

[François DORIN]

Bonjour,

Je ne connaissais pas le ImmutableList que j'ai installé (Nuget). Par contre new ImmutableList<T>(int longueurDeLaListe) ne semble pas exister. J'ai dont bricolé

Code :

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

ImmutableList<Pt> points = new List<Pt>(dtPoints.Rows.Count).ToImmutableList();

qui ne me semble pas très propre visuellement mais qui a l'air de fonctionner.
Je me doutait que je pouvais avoir des problèmes avec l'alimentation de ma List, c'est pourquoi j'avais fais

Code :

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

1
2
3
4
5
6
7
                           if (newPoint != null)
                           {
                               lock (obj)
                               {
                                   points.Add(newPoint);
                               }
                           }

car je me disais qu'en "lockant" la liste, elle ne pourrait pas être alimentée par 2 Threat en même temps, mais que les Threat devraient attendre leur tour. Peut-être étais-je dans l'erreur ou, ce à quoi je pensais, ça ralenti l'alimentation de la liste si des Threat doivent attendre.

Utiliser lock est ici la bonne approche. La ImmutableList ici est tout ce qu'il y a de contre-productif

• ajouter énormément d'éléments un par un provoque une pression assez importante au niveau du garbage collector (beaucoup d'allocation et donc de nettoyage à faire) ;
• c'est lent : chaque modification nécessite de construire une nouvelle liste indépendante de la première. Rajouter 1000 éléments nécessite donc de créer 1000 nouvelles listes !
• ce n'est pas threadsafe. Qu'on s'entende bien : les appels aux méthodes de la liste le sont (puisque la liste est non modifiable, il n'y a pas de risque), mais il faut des précautions derrières si on veut que la liste soit mise à jour. Or faire un list = list.Add(item) n'est pas thread safe car il s'agit de deux instructions : appel de la méthode, et assignation de la valeur de retour !!! Il faut donc impérativement utiliser... un lock ! Du coup, l'utilisation d'une ImmutableList n'a plus de sens.

Enfin, je modifierai à minima le code ainsi :

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
40
41
42
43
44
45
46
47
48
static async Task<ObservableCollection<Pt>> ImportPointAsync(int srid, string mdbPath, IProgress<int> progress)
        {
            DataTable dtPoints = new DataTable();
            DataTable dtPCodes = new DataTable();
 
            --- chargement des tables à partir de la mdb ---
 
            if (dtPoints == null || dtPoints.Rows.Count == 0 || dtPCodes == null || dtPCodes.Rows.Count == 0)
                return null;
            ImmutableList<Pt> points = new List<Pt>(dtPoints.Rows.Count).ToImmutableList();
            int totalCount = 0, count = 1, i=0;
            Object obj = new Object();
            var maListeDeListesDePoints = dtPoints.Rows.OfType<System.Data.DataRow>().GroupBy(x => i++ / 5).Select(x => x.ToList()).ToList(); // Constitue des listes de 5 points
            totalCount = maListeDeListesDePoints.Count;
            await Task.Run(() =>
            Parallel.ForEach(maListeDeListesDePoints, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount / 2 }, listeDePoints => {
                       for (int j=0; j< listeDePoints.Count; j++)
                       {
                           DataRow drPoint = listeDePoints[j];
                           DataRow[] drsPCodes = dtPCodes.Select("IdPoint = " + drPoint["IdPoint"]);
                           List<int> lstPCodes = new List<int>();
                           foreach (DataRow drPCode in drsPCodes)
                           {
                               int pcode = 0;
                               if (drPCode != null && int.TryParse(drPCode["PCode"].ToString(), out pcode))
                                   lstPCodes.Add(pcode);
                           }
                           Pt newPoint = new Pt(drPoint["nomPoint"].ToString(), (double)drPoint["PointX"], (double)drPoint["PointY"], lstPCodes, srid);
                           if (newPoint != null)
                            points.Add(newPoint);
                       }
                       if (progress != null)
                       { 
                           int progressCount;
                           lock (obj)
                           {
                              count++;
                              progressCount = count;
                           }
 
                           progress.Report((progressCount * 100 / totalCount));
                       }
                   })
                );
            if (points != null && points.Count > 0)
                return new ObservableCollection<Pt>(points.Distinct());
            return null;
        }

Ainsi :

• le lock n'est réalisé que s'il est nécessaire de reporter la progression
• la durée d'acquisition du lock est minimisée (et donc minimise le risque de blocage)

[Jean-Marc68]

Merci de ton avis concernant le ImmutableList et ma manière d'alimenter la List "standard" avec un lock, François.
Avec les tests que j'avais fais il ne me manquait pas de point. Mais selon les autres avis je me disais que j'avais peut-être eu de la chance.
La partie dont le parle

Code :

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

1
2
3
4
5
6
7
if (newPoint != null)
{
    lock (obj)
    {
        points.Add(newPoint);
    }
}

Par contre je ne comprend pas bien ta proposition

Code :

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

1
2
3
4
5
6
7
8
9
10
if (progress != null)
{ 
     int progressCount;
     lock (obj)
     {
       count++;
       progressCount = count;
     }
     progress.Report((progressCount * 100 / totalCount));
}

J'avais instancié le count hors du Parallel.foreach pour que sa valeur se maintienne et qu'elle reprenne les valeurs générées par tous les foreach parallèles. J'ai mis le count++ dans le foreach pour que chaque foreach parallèle alimente le même count et je l'ai mis dans un lock pour empêcher la double alimentation simultanée. Selon mes tests ça fonctionnait bien aussi.
Il me semble que comme le progress.Report ne fait que lire la valeur du count, donc comme le count n'a pas besoin d'être modifié il n'est pas nécessaire de mettre le progress.Report dans le lock (mais ce serait neanmoins possible).
Pourquoi créer un int progressCount dans chaque foreach parallèle et faire lire le progressCount par le progress.Report au lieu de lui faire lire le count ?

Merci