Discussion :

[Dudule70]

Bonjour à tous,
En quelques mots voici ma situation :
Après extraction des données de plusieurs fichiers, mis au format texte, j’ai environ 2 millions de lignes qui contiennent chacune 22 paramètres différents pour l’analyse détaillée de ces données. (format: data1; data2; data3; …; data22; )

Par contre pour avoir fait le tour des collections génériques List<T> … , j’ai du mal à m’arrêter sur une technologie bien précise, en sachant que je recherche aussi la rapidité d’exécution.

J’aimerai avoir votre avis éclairé pour mon orientation vers la meilleure solution.
En vous remerciant pour votre aide.
Cordialement.

NB:
J'ai toujours eu un faible pour ce qui ressemble « aux bonnes vieilles listes chainées avec pointeurs » mais j'ai peur d'avoir des surprises et de ne pas être des plus efficace.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
           List<string> lines = new List<string>();
           lines = formatage.PremierFormatage(f.FichierSelect()); // Recupération data
           string[] arrayListe = new string[lines.Count];
           lines.CopyTo(arrayListe, 0);
           LinkedList<string> ll = new LinkedList<string>(arrayListe);
           LinkedListNode<string> courant = ll.First;
 
            while (courant != null)
            {
               // Faire mes traitements ici
                courant = courant.Next;
            }

[lead8209]

Salut, tu peux réduire un peut ton code... :

Code :

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

1
2
3
4
5
6
 
List<string> lignes = formatage.PremierFormatage(f.FichierSelect()); // Recupération data
            foreach (var ligne in lignes)
            {
                //traitement ici
            }

Après c'est un peu dangereux de tout charger en mémoire. Tu n'as pas peur que cela explose ?
Avec de gros fichiers en général on travaille par blocs d'une taille donnée. C'est peut-être plus lent (quoi que) et ça ne bourre pas la mémoire.
Est-il absolument nécessaire d'avoir l'intégralité des fichiers en mémoire ?
Si tu expliques un petit peu la fonctionnalité on pourra peut-être te donner quelques tuyaux ?

A+

[Dudule70]

Bonjour lead8209,
Je te remercie pour ton aide.

Voici le projet en quelques mots : On assemble de 2 éléments en fonction de sa géométrie.
Les machines retournent leurs résultats dans un fichier journalier. 22 données pour une ligne (texte) et par pièce (fichier type SPC).

L’analyse de ces résultats peut être journalière ou mensuelle.
Pour certain critères je dois faire du comptage et pour les autres des statistiques sur un période donnée avec affichage de toutes ces populations avec des TChart.

Tu as raison c'est lourd ! Pour l’instant je suis dans la pré-étude, d’où mes interrogations :
Comment faire pour traiter ce flot de donnée? A partir avec des collections génériques ? Des listes ?...

Je peux découper mes fichiers sans problème. J’ai déjà testé un liste avec un count = 1908100 ça passe mais la mémoire prend une gifle et je ne suis sûr qu’avec les calculs stats cela puisse passer.

En vous remerciant pour les tuyaux !

[lead8209]

Salut,
pour alléger la lecture tu peux faire du ligne à ligne :

Si tu as toujours la même structure de données dans des fichiers je te conseille de parser les résultats dans une classe.
Par exemple si ton fichier contient 3 colonnes (date, N° série machine, Pression) :

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
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
 
 
 public static class Program
    {
        public static void main(string[] args)
        {
            List<Machine> machines = new List<Machine>();
 
            Parser.Parse(new FileInfo(@"C:\machine1.txt"), ref machines);
            Parser.Parse(new FileInfo(@"C:\machine2.txt"), ref machines);
            Parser.Parse(new FileInfo(@"C:\machine3.txt"), ref machines);
 
            Statistiques.AffichePressMoyenneParMachine(machines);
        }
    }
 
 
public static class Parser
    {
        public static void Parse(FileInfo pFichier, ref List<Machine> pMachines)
        {
            pFichier.Refresh();
            if(!pFichier.Exists)
            {
                throw new ArgumentException("Le fichier est introuvable");
            }
            using (StreamReader sr = new StreamReader(pFichier.FullName))
            {
                string ligne = null;
                while ((ligne = sr.ReadLine()) != null)
                {
                    //traitement sur la ligne
                    string[] split = ligne.Split('\t');
                    string nsMachine = split[0];
                    Machine machine = pMachines.Where(m => m.m_NumSerie == nsMachine).FirstOrDefault();
                    if(machine == null)//nouvelle machine à ajouter à la liste
                    {
                        machine = new Machine(nsMachine);
                        pMachines.Add(machine);
                    }
 
                    DateTime date = Convert.ToDateTime(split[1]);
                    double pression = Convert.ToDouble(split[2]);
 
                    machine.m_Donnees.Add(new Donnee(date, pression));
                }
            }
        }
    }
 
    public static class Statistiques
    {
        public static void AffichePressMoyenneParMachine(List<Machine> pMachines)
        {
            foreach (var machine in pMachines)
            {
                Console.WriteLine("Machine {0} : {1}Pa", machine.m_NumSerie, Math.Round(machine.m_PressionMoyenne, 2));
            }
        }
    }
 
 
    public class Machine
    {
        public readonly string m_NumSerie;
        public List<Donnee> m_Donnees = new List<Donnee>();
        public double m_PressionMoyenne
        {
            get
            {
                if(this.m_Donnees.Count == 0)
                {
                    return 0;
                }
 
                return this.m_Donnees.Average(d => d.m_Pression);
            }
        }
 
        public Machine(string pNumSerie)
        {
            m_NumSerie = pNumSerie;
 
        }
    }
 
    public class Donnee
    {
        public readonly DateTime m_Date;
        public readonly double m_Pression;
 
        public Donnee(DateTime pDate, double pPression)
        {
            m_Date = pDate;
            m_Pression = pPression;
        }
    }

Tu remarqueras également qu'on lit le fichier ligne à ligne; on n'a ainsi dans la mémoire que les données machine et plus l'intégralité des fichiers.

[Dudule70]

Excellent lead8209 !
J'ai compris l'idée même si je ne suis pas familiarisé avec les expressions Link.
Y a plus qu'a bosser le code.
En attendant, je te remercie beaucoup pour ton aide.
Cordialement.

[lead8209]

Salut, avec plaisir.
Pas de Linq ici seulement des expressions lambda
Tu peux essayer les deux ce sont des outils très puissants et complémentaires. Ils te seront d'une grande utilité quand tu voudras écrire la partie statistiques. Ça t'épargnera BEAUCOUP de lignes de code...

Bon courage pour la suite.