Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

c# comment améliorer ses performances


Sujet :

C#

  1. #1
    Nouveau membre du Club
    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 ^^

  2. #2
    Membre à l'essai
    Personnellement, j'essaye de factoriser au maximum mon code en évitant les boucles et les requêtes inutiles.

  3. #3
    Nouveau membre du Club
    Citation Envoyé par Kikibolderiz Voir le message
    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 ?

  4. #4
    Membre à l'essai
    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.

    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.

  5. #5
    Nouveau membre du Club
    Citation Envoyé par Kikibolderiz Voir le message
    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 ^^'

  6. #6
    Membre expérimenté
    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.
    Keep calm and debug it

  7. #7
    Nouveau membre du Club
    Citation Envoyé par PixelJuice Voir le message
    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

  8. #8
    Membre expert
    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

  9. #9
    Nouveau membre du Club
    Citation Envoyé par youtpout978 Voir le message
    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

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

    Tu affiches combiens de lignes et de colonnes ?

  11. #11
    Expert éminent
    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 csharp :Sélectionner tout -Visualiser dans une fenêtre à part
    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 csharp :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
    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 :

    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
    On ne jouit bien que de ce qu’on partage.

  12. #12
    Nouveau membre du Club
    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 :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
    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?)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<minute>\d\d?)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<seconde>\d\d?)?.+(?<ampm>[AP]M)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<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 :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
    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 :Sélectionner tout -Visualiser dans une fenêtre à part
    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;

  13. #13
    Expert éminent
    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 csharp :Sélectionner tout -Visualiser dans une fenêtre à part
    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 csharp :Sélectionner tout -Visualiser dans une fenêtre à part
    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 csharp :Sélectionner tout -Visualiser dans une fenêtre à part
    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 csharp :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
     
    // 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 csharp :Sélectionner tout -Visualiser dans une fenêtre à part
    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?)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<minute>\d\d?)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<seconde>\d\d?)?.+(?<ampm>[AP]M)?<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<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

    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).
    On ne jouit bien que de ce qu’on partage.

  14. #14
    Nouveau membre du Club
    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 :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
     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))<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<minute>(\d\d))<img src="images/smilies/icon_sad.gif" border="0" alt="" title=":(" class="inlineimg" />?<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 ^^'

  15. #15
    Membre confirmé
    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+

  16. #16
    Nouveau membre du Club
    Citation Envoyé par Donpi Voir le message
    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 ^^

  17. #17
    Nouveau membre du Club
    Test Regex vs Contains

    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é

  18. #18
    Expert éminent sénior
    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
    Cours complets, tutos et autres FAQ ici : C# - VB.NET

  19. #19
    Nouveau membre du Club
    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

  20. #20
    Nouveau membre du Club
    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

###raw>template_hook.ano_emploi###