c# comment améliorer ses performances

Version imprimable

13/08/2020, 08h43
Dragz_

c# comment améliorer ses performances

Je me permet de créer une discussion qui à surement des jumelles, mais je me pose la question "Ou gagner de la performance ?", j'ai débuter il y a peu et je me retrouve à faire des applicatifs qui ne sont pas très léger donc si je peux gagner en performance et en vitesse d’exécution je suis preneur ^^
13/08/2020, 09h07
Kikibolderiz

Personnellement, j'essaye de factoriser au maximum mon code en évitant les boucles et les requêtes inutiles.
13/08/2020, 09h10
Dragz_

Citation:

Envoyé par Kikibolderiz

Personnellement, j'essaye de factoriser au maximum mon code en évitant les boucles et les requêtes inutiles.

Quand tu dis factoriser, tu parles de faire des fonctions ?
13/08/2020, 09h28
Kikibolderiz

Factoriser, c'est réduire son code en rassemblant les lignes d'instructions qui se ressembles (pourquoi faire quelques chose en 10 lignes quand tu peux le faire en 1 seul) et ça permet une meilleur lisibilité et maintenance de ton code.

Citation:

tu parles de faire des fonctions ?

J'utilise des fonctions le plus possible "générique" quand je vois que j'utilise une suite d'instructions plusieurs fois dans mon projet.
13/08/2020, 10h16
Dragz_

Citation:

Envoyé par Kikibolderiz

Factoriser, c'est réduire son code en rassemblant les lignes d'instructions qui se ressembles (pourquoi faire quelques chose en 10 lignes quand tu peux le faire en 1 seul) et ça permet une meilleur lisibilité et maintenance de ton code.

J'utilise des fonctions le plus possible "générique" quand je vois que j'utilise une suite d'instructions plusieurs fois dans mon projet.

c'est ce que j'ai fais aussi mais mon applis doit parcourir des fichiers de milliers de lignes et triers la valeur dans un datagridview, mais mon datagridview est en sueur au moment de l'affichage ^^'
13/08/2020, 10h33
PixelJuice

Bonjour,

Il y a plein de façons d'améliorer les performances d'un programme mais dans ton cas il faudra peut-être faire un peu d'UI/UX.

Est-il pertinent d'afficher toutes les lignes d'un coup ? Faut-il un système de recherche ? Des filtres ? D'autres DataGridView ? etc ...

Il existe aussi quelques astuces pour booster les performances du DataGridView, tel que passer sa propriété DoubleBuffered à true (cette astuce est valable pour la plupart des contrôles WinForm). Mais il en existe sûrement des autres.
13/08/2020, 10h45
Dragz_

Citation:

Envoyé par PixelJuice

Bonjour,

Il y a plein de façons d'améliorer les performances d'un programme mais dans ton cas il faudra peut-être faire un peu d'UI/UX.

Est-il pertinent d'afficher toutes les lignes d'un coup ? Faut-il un système de recherche ? Des filtres ? D'autres DataGridView ? etc ...

Il existe aussi quelques astuces pour booster les performances du DataGridView, tel que passer sa propriété DoubleBuffered à true (cette astuce est valable pour la plupart des contrôles WinForm). Mais il en existe sûrement des autres.

je fais déjà des filtres pour récupérer uniquement ce qui m'intéresse mais cela me laisse toujours trop de ligne à mon goûts, qu'est ce que UI/UX, je vais me renseigner sur le doublebuffered, j'avais penser à une pagination :?
13/08/2020, 20h23
youtpout978

Il y a des datagrid avec système de virtualisation des données
https://docs.microsoft.com/fr-fr/dot...idview-control

après je ne sais pas quel moteur 'asp, wpf, winforms ..) et quel contrôle tu utilises, il y a des controles tiers qui sont performants sur les gros volumes de données
14/08/2020, 08h55
Dragz_

Citation:

Envoyé par youtpout978

Il y a des datagrid avec système de virtualisation des données
https://docs.microsoft.com/fr-fr/dot...idview-control

après je ne sais pas quel moteur 'asp, wpf, winforms ..) et quel contrôle tu utilises, il y a des controles tiers qui sont performants sur les gros volumes de données

Je suis en windform avec un datagridview
14/08/2020, 09h08
youtpout978

Ça tombe bien le lien que je t'ai donnée est pour winforms.

Tu affiches combiens de lignes et de colonnes ?

Si avoir une application qui ne répond pas pendant qu'elle travaille (plus rapidement) ne te déranger pas, tu peux utiliser SuspendLayout() en début de traitement et ResumtLayout() et fin de traitement.

Tu peux l'utiliser sur la Grid (pour ne freezer que la Grid) ou toute la Form.
Ceci permet de bloquer tous les événements relatifs à l'affichage, qui sont généralement les plus consommateurs...

Mais attention, pendant le traitement, du coup ton contrôle fige, et est inutilisable en plus d'être moche.

Ensuite, un bémol à propos de la refactorisation.

D'un point de vue maintenance, oui, la factorisation fait gagner un temps fou.
En revanche, en termes d'exécution, ce n'est pas vrai.
Rien n'est plus rapide qu'un programme "kilométrique" spécifique (dans la limite du raisonnable évidemment, car la rançon de cette vitesse se fait généralement au détriment de la taille mémoire notamment).

Code:

1
2
3
4
5
6
7
8
9
10
 
Console.WriteLine("1");
Console.WriteLine("2");
Console.WriteLine("3");
Console.WriteLine("4");
Console.WriteLine("5");
 
for (int i = 1; i <= 5; i++) {
   Console.WriteLine(i.ToString());
}

Le premier c'est 5 instructions, l'autre c'est... 20 instructions à l'exécution (sans parler de toute la mécanique d'allocation de variable, le ToString(), etc. !)

Sinon, pour améliorer les performances, il faut généralement traiter en priorité :
- l'algorithme (un programme lent est souvent un programme qui est mal pensé)
- réduire au maximum les IO (disque, réseau, mémoire)
- l'interface utilisateur => calculer, et n'afficher le résultat qu'une fois terminé (double buffer, SuspendLayout, mais aussi et surtout bosser sur des variables séparées que celles utilisées pour l'affichage)
- la syntaxe (préféer un if { for {} } else { for {} } qu'un for { if {} else {} } par exemple, éviter les traitements de chaîne inutiles, etc. la liste est très longue)
- mais toujours garder à l'esprit la pression mémoire, qui peut foutre en l'air tout le travail d'optimisation (genre éviter de charger d'un coup un fichier de 10 Go en mémoire, même si au final on doit le retraiter intégrallement)

Pour les sceptiques à propos du factorisé vs optimisée, voici un exemple simple avec un calcul de factorielle :

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
using System;
using System.Diagnostics;
 
namespace Factorielle
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            ulong i, j;
 
            Console.WriteLine("Methode Récursive (la plus factorisée, la moins optimisée)");
            sw.Restart();
            for (j = 0; j < 10000000; j++)
            {
                for (i = 0; i < 21; i++)
                {
                    MethodeRecursive.Factorielle(i);
                }
            }
            Console.WriteLine(sw.ElapsedMilliseconds + " ms");
 
            Console.WriteLine("Methode Iterative (moins factorisée, plus optimisée)");
            sw.Restart();
            for (j = 0; j < 10000000; j++)
            {
                for (i = 0; i < 21; i++)
                {
                    MethodeIterative.Factorielle(i);
                }
            }
            Console.WriteLine(sw.ElapsedMilliseconds + " ms");
 
            Console.WriteLine("Methode Déclarative (la moins factorisée, la plus optimisée)");
            sw.Restart();
            for (j = 0; j < 10000000; j++)
            {
                for (i = 0; i < 21; i++)
                {
                    MethodeDeclarative.Factorielle(i);
                }
            }
            Console.WriteLine(sw.ElapsedMilliseconds + " ms");
        }
    }
 
static class MethodeRecursive
    {
        public static ulong Factorielle(ulong i)
        {
            if (i > 20) return 0;
            if (i <= 1)
            {
                return 1;
            }
            else
            {
                return i * Factorielle(--i);
            }
        }
    }
 
    static class MethodeIterative
    {
        public static ulong Factorielle(ulong i)
        {
            if (i > 20) return 0;
            ulong res = 1;
            while (i > 1)
            {
                res *= i--;
            }
            return res;
        }
    }
 
    static class MethodeDeclarative
    {
        public static ulong Factorielle(ulong i)
        {
            return i switch
            {
                0 => 1,
                1 => 1,
                2 => 2,
                3 => 6,
                4 => 24,
                5 => 120,
                6 => 720,
                7 => 5040,
                8 => 40320,
                9 => 362880,
                10 => 3628800,
                11 => 39916800,
                12 => 479001600,
                13 => 6227020800,
                14 => 87178291200,
                15 => 1307674368000,
                16 => 20922789888000,
                17 => 355687428096000,
                18 => 6402373705728000,
                19 => 121645100408832000,
                20 => 2432902008176640000,
                _ => 0,
            };
        }
    }
}

Le résultat est sans appel :

Citation:

Methode Récursive (la plus factorisée, la moins optimisée)
13429 ms
Methode Iterative (moins factorisée, plus optimisée)
5969 ms
Methode Déclarative (la moins factorisée, la plus optimisée)
1250 ms

Exemple concret

Voici ce qui me prend le plus de temps, je dois trier des fichiers de plusieurs milliers de lignes j'ai créé cette fonction pour trier :

Code:

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
49
50
51
52
53
54
55
56
 public static LogParse Trie(string lignes, string nomFichier, string[] types)
        {
            string[] finder = new string[types.Length];
            if (nomFichier.StartsWith("Logis"))
            {
                if (types[0] == "Erreur")
                    finder[0] = "N_ERREUR";
                else
                    finder[0] = "XxX";
 
                if (types[1] == "Warning")
                    finder[1] = "N_WARNING";
                else
                    finder[1] = "XxX";
 
                if (types[2] == "Defaut")
                    finder[2] = "N_DEFAUT";
                else
                    finder[2] = "XxX";
 
                string[] ligneArray = lignes.Split('\t'); //sépare les chaînes à partir
                string pattern = @"(?<mois>\d\d?)?/(?<jour>\d\d?)?/(?<annee>\d{4})?\s+(?<heure>\d\d?)?:(?<minute>\d\d?)?:(?<seconde>\d\d?)?.+(?<ampm>[AP]M)?:(?<ms>\d{1,3})?.+(?<x>" + finder[0] + "|" + finder[1] + "|" + finder[2] + ")";
                Match m = Regex.Match(lignes, pattern);
                if (m.Success)
                {
                    int jour = int.Parse(m.Groups["jour"].Value);
                    int mois = int.Parse(m.Groups["mois"].Value);
                    int annee = int.Parse(m.Groups["annee"].Value);
                    int heure = int.Parse(m.Groups["heure"].Value);
                    int minute = int.Parse(m.Groups["minute"].Value);
                    int secondes = int.Parse(m.Groups["seconde"].Value);
 
                    string MS = m.Groups["ms"].Value;
                    int ms = 0;
                    if (!string.IsNullOrWhiteSpace(MS))
                    {
                        ms = int.Parse(MS);
                        if (MS.Length == 1)
                            ms *= 100;
                        else if (MS.Length == 2)
                            ms *= 10;
                    }
                    DateTime date = new DateTime(annee, mois, jour, heure, minute, secondes, ms);
                    if (m.Groups["ampm"].Value == "PM")
                        date = date.AddHours(12);
                    return new LogParse
                    {
                        Datation = date,
                        Identificateur = "LogisticCore",
                        Module = ligneArray[1],
                        Type = m.Groups["x"].Value,
                        Info = ligneArray[3],
                        Details = ligneArray[4],
                    };
                }
            }

et je l’appelle comme ceci :

Code:

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
public void ChargerFichier(int i, List<string> cheminFichierOk)
        {
            string[] types = new string[3];
            if (stateErreur == true)
                types[0] = "Erreur";
 
            if (stateWarning == true)
                types[1] = "Warning";
 
            if (stateDefaut == true)
                types[2] = "Defaut";
 
            for (int j = 0; j < cheminFichierOk.Count - i; j++)
            {
                using (FileStream fs = File.Open(cheminFichierOk[j], FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                using (BufferedStream bs = new BufferedStream(fs))
                using (StreamReader sr = new StreamReader(bs))
                {
                    string line;
                    while ((line = sr.ReadLine()) != null)
                    {
                        LogParse leLog = LogParse.Trie(line, Path.GetFileName(cheminFichierOk[j]), types);
                        if (leLog != null)
                            lesLogs.Add(leLog);
                    }
                }
            }
            lesLogs = lesLogs.OrderBy(x => x.Datation).ToList();
        }

et enfin mon affichage dans un datagridview

Code:

1
2
3
4
5
6
dtgLog.DataSource = lesLogs;
            groupementModule = lesLogs.GroupBy(l => l.Module).Select(g => new LogGroupe(g)).ToList();
 
            groupementModule.Insert(0, new LogGroupe("Tous les enregistrements", lesLogs));
 
            lbxModule.DataSource = groupementModule;

Bonjour,

Il n'y a rien de bien flagrant qui me saute aux yeux, mais quelques axes d'amélioration :

Syntaxe :
Evite au maximum mes if et else sans crochets, ou alors met-les sur une seule ligne :
Code:

1 2 3 if (a == b) DoSomeThing(); else DoNothing();
En effet, si demain tu dois rajouter quelque chose, il y a de grandes chances pour que tu oublies de mettre les accolades.
De manière plus générale, je t'invite à lire cet article, et éviter comme la peste toutes les syntaxes présentées, sauf si tu souhaites être le seul à pouvoir maintenir le programme, et facturer 3 jours de dev pour chaque modification mineure.
https://www.se.rit.edu/~tabeec/RIT_4...ble%20Code.pdf.

Redondance de code, utilisation inutile de mémoire/allocations/valeurs littérales :

Ce code appelé avant ta méthode Trie()
Code:

1 2 3 4 5 6 7 8 9 10 string[] types = new string[3]; if (stateErreur == true) types[0] = "Erreur"; if (stateWarning == true) types[1] = "Warning"; if (stateDefaut == true) types[2] = "Defaut";
Est partiellement inutile et redondant avec le code qui se trouve à l'intérieur :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 if (types[0] == "Erreur") finder[0] = "N_ERREUR"; else finder[0] = "XxX"; if (types[1] == "Warning") finder[1] = "N_WARNING"; else finder[1] = "XxX"; if (types[2] == "Defaut") finder[2] = "N_DEFAUT"; else finder[2] = "XxX";
A mon sens, tu peux grandement simplifier (et améliorer les perfs, et soulager le GC) comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 // Au niveau de la classe const string N_ERREUR = "N_ERREUR"; const string N_WARNING = "N_WARNING"; const string N_DEFAUT = "N_DEFAUT"; const string XxX = "XxX"; [...] // Lors de l'appel à ta méthode string finder_1 = (stateErreur == true) ? N_ERREUR : XxX; string finder_2 = (stateWarning == true) ? N_WARNING : XxX; string finder_3 = (stateDefaut == true) ? N_DEFAUT : XxX; [...] // Dans ta boucle LogParse leLog = LogParse.Trie(line, Path.GetFileName(cheminFichierOk[j]), finder_1, finder_2, finder_3);
Code:

1 2 3 4 5 6 7 public static LogParse Trie(string lignes, string nomFichier, string finder_1, string finder_2, string finder_3) { [...] string pattern = @"(?<mois>\d\d?)?/(?<jour>\d\d?)?/(?<annee>\d{4})?\s+(?<heure>\d\d?)?:(?<minute>\d\d?)?:(?<seconde>\d\d?)?.+(?<ampm>[AP]M)?:(?<ms>\d{1,3})?.+(?<x>" + finder_1 + "|" + finder_2 + "|" + finder_3 + ")"; [...] }
Ensuite, j'ai l'impression que ton expression régulière est constante d'un appel à l'autre : donc simplifie encore plus pour la déclarer une et une fois pour toute en dehors de la méthode, et passe l'instance de l'objet RegExp() en paramètre : toujours réutiliser au maximum les instances des objets (surtout quand ils sont lourds) plutôt que de les recréer dans une boucle !

Dans ta fonction, je vois bien un if () qui permet de retourner une instance d'objet, mais pas de else... Où est-il ? En l'état ta fonction ne compile pas.

Quant à la RexExp, j'avoue que je ne vois pas trop à quoi elle sert.
Je pense que c'est très lourd si c'est juste pour lire un DateTime, qui semble de plus écrit dans un format plutôt standard.
Un ou plusieurs DateTime.TryParse() me semble bien plus simple et performant, d'autant que ta fonction est buggée : tu inverses minuit (12:00 AM) et midi (12:00 PM) (oui, chez les américains 12:00 AM est entre 11:59 PM et 0:01 AM, c'est très logique)
https://docs.microsoft.com/fr-fr/dot...tem_DateTime__

Enfin, lire un fichier texte ligne à ligne est lent, très lent. Je vais essayer de retrouver un vieux topic dans lequel j'avais proposé différentes solutions allant jusqu'à 20 fois plus vite (de mémoire).

-- Edit : trouvé !
https://www.developpez.net/forums/d1...x/#post8009395
C'est d'ailleurs toi qui a participé dedans le dernier, mais je n'ai pas bien compris ton problème :D

Regarde la méthode "SimpleBlockReader".
Le but c'est de réduire au maximum les IO disque, car c'est de loin ce qui est le plus lent dans un programme (après les IO réseau peut-être).

ce n'est pas un else mais un if je trie pareil mais avec un autre nom de fichier (je sais que c'est du mauvais code mais c'était au début j'ai pas pris la peine de changer)
Code:

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 if (nomFichier.StartsWith("traffic")) { if (types[0] == "Erreur") finder[0] = "error"; else if (types[1] == "Warning") finder[1] = "warning"; else if (types[2] == "Defaut") finder[2] = "defaut"; string[] ligneArray = lignes.Split(']'); string pattern = @"(?<annee>\d{4})-(?<mois>(\d\d))-(?<jour>(\d\d))\s(?<heure>(\d\d)):(?<minute>(\d\d)):(?<seconde>(\d\d)).(?<ms>(\d{3})).+(?<x>" + finder[0] + "|" + finder[1] + "|" + finder[2] + ")"; Match m = Regex.Match(lignes, pattern); if (m.Success) { int jour = int.Parse(m.Groups["jour"].Value); int mois = int.Parse(m.Groups["mois"].Value); int annee = int.Parse(m.Groups["annee"].Value); int heure = int.Parse(m.Groups["heure"].Value); int minute = int.Parse(m.Groups["minute"].Value); int secondes = int.Parse(m.Groups["seconde"].Value); DateTime date = new DateTime(annee, mois, jour, heure, minute, secondes); foreach (string ligne in ligneArray) { for (int i = 0; i < 5; i++) ligneArray[i] = ligneArray[i].Replace("[", ""); } return new LogParse { Datation = date, Identificateur = "Traffic", Module = ligneArray[1], Type = m.Groups["x"].Value, Info = ligneArray[3], Details = ligneArray[4], }; } }
Le code en question

j'avais vu les tests que tu avais effectués mais je n'ai pas su les utilisés (au moment ou j'ai fait mon app), mais c'est clair que le problème vien de la

pour ma regex je trie des fichiers qui ont cet tête la
1/30/2020 4:01:29 PM:454 Gestionnaire Attribution C_BEGIN Abonne::setAbonne [L:228] Abonné n°-7 - Gestionnaire Attribution ON
1/30/2020 4:01:29 PM:456 Gestionnaire Attribution C_END Abonne::setAbonne [L:256] CodeResult = CODE_OK
1/30/2020 4:01:29 PM:458 Gestionnaire Attribution C_CREATE Abonne::Abonne [L:96] Abonné n°-7 : Gestionnaire Attribution
1/30/2020 4:01:29 PM:548 Gestionnaire attribution C_BEGIN Abonne::setAbonne [L:228] Abonné n°3 - Gestionnaire attribution ON
1/30/2020 4:01:29 PM:551 Gestionnaire attribution C_END Abonne::setAbonne [L:256] CodeResult = CODE_OK
1/30/2020 4:01:29 PM:554 Gestionnaire attribution C_CREATE Abonne::Abonne [L:96] Abonné n°3 : Gestionnaire attribution
1/30/2020 4:01:29 PM:554 Gestionnaire attribution C_CREATE GestAttribution::GestAttribution [L:260] Gestionnaire Attribution
1/30/2020 4:01:29 PM:554 Gestionnaire attribution C_INIT GestAttribution::initialise [L:270] Gestionnaire Attribution

le pm me semblais bon car 4H pm ça me donne bien 16h ^^'

pour ce qui est de la regex j'avais été aidé car je ne connaissais pas ce genre de filtre donc cela me semblais bon, mais de ce que j'ai compris je fais fausse route ^^'

19/08/2020, 06h32
Donpi

Selon moi le meilleur moyen de gagner en performance c'est de savoir comment fonctionnent les choses.

Sur ces 20 dernières années il y a passablement de connaissances informatiques qui ne sont plus transmises lors de formations "standards".
Ceux qui ont eu leur formation à l'époque ou être informaticien c’était comme être un gladiateur ont ce savoir et ces réflexes qui se perdent. ( avant Windows 95 )

Aujourd'hui avec les milliers de couches il y a toute une génération de développeurs qui ne sait même pas comment sont géré les variables etc...
Pour vraiment gagné en performance il faut revenir au sources.

A+
19/08/2020, 08h49
Dragz_

Citation:

Envoyé par Donpi

Selon moi le meilleur moyen de gagner en performance c'est de savoir comment fonctionnent les choses.

Sur ces 20 dernières années il y a passablement de connaissances informatiques qui ne sont plus transmises lors de formations "standards".
Ceux qui ont eu leur formation à l'époque ou être informaticien c’était comme être un gladiateur ont ce savoir et ces réflexes qui se perdent. ( avant Windows 95 )

Aujourd'hui avec les milliers de couches il y a toute une génération de développeurs qui ne sait même pas comment sont géré les variables etc...
Pour vraiment gagné en performance il faut revenir au sources.

A+

Je vais m'y atteler alors ^^
19/08/2020, 10h46
Dragz_

2 pièce(s) jointe(s)

Test Regex vs Contains

Pièce jointe 577469
j'ai fais un test et je viens de voir que la fonction string contains me prenais 3x moins de temps qu'un regex, je vais donc tester une nouvelle méthode pour réduire mon temps, je suis passé par un ReadAllText

Edit --

En passant par un readAllLines cela deviens encore plus rapide et apparemment deviendrais instantané Pièce jointe 577470
21/08/2020, 08h41
Pol63

j'ai vu des regex 1000x moins performantes que l'équivalent en algo
une regex c'est pour tester un string de temps en temps genre un input utilisateur
donc oui c'est à éviter si t'en fais à la chaine
21/08/2020, 08h51
Dragz_

Effectivement j'en fais à la chaîne, je ne connaissais pas et c'est ce qu'on ma conseiller sur un autre forum à l'avenir je serais têtue :mouarf:
21/08/2020, 09h36
Dragz_

Je suis moins embêté par l'acquisition de mes données mais plus pas l'affichage dans mon datagridview qui lui met encore du temps à afficher, je sais pas si une pagination pourrais aidé à alléger l'affichage mais la multitude d'exemple disponible sur internet na pas su m'aider à implémenter la pagination si vous sauriez m'aider, je suis preneur :D
21/08/2020, 13h22
Pol63

Sur le dgv il y a virtualmode qui permet de booster les perfs quand il y’a beaucoup de données.
Tu l’as sûrement déjà dit mais j’ai pas lu mais faudrait voir le nombre de lignes
En virtualmode j’en ai déjà affiché plusieurs millions sans problème. Ça demande un peu de code en plus par contre, et de comprendre le principe.
21/08/2020, 13h26
Dragz_
Citation:

Envoyé par Pol63

Sur le dgv il y a virtualmode qui permet de booster les perfs quand il y’a beaucoup de données.
Tu l’as sûrement déjà dit mais j’ai pas lu mais faudrait voir le nombre de lignes
En virtualmode j’en ai déjà affiché plusieurs millions sans problème. Ça demande un peu de code en plus par contre, et de comprendre le principe.

J'ai effectivement ajouté le virtual mode (la ligne du control je l'ai passé à true) j'ai couplé ça à un doubleBuffered
Code:

1 2 typeof(Control).InvokeMember("DoubleBuffered", BindingFlags.SetProperty | BindingFlags.Instance | BindingFlags.NonPublic, null, dtgLog, new object[] { true });
maintenant l'affichage ce fait très rapidement, du moins plus vite qu'avant