Discussion :

[Keyem]

Bonjour à tous,

Actuellement, je dois lire des fichers "csv" afin d'y extraire des informations et tracer des courbes. Cela fonctionne.

Maintenant, afin d'obtimiser le fonctionnement du programme, je souhaiterais ignorer certaines lignes (ex: traiter seulement 1 ligne sur 10) de mon fichier afin de rendre le traitement plus rapide (les fichiers "csv" peuvent atteindre 20 Mo) ...

Auriez-vous une solution qui évite d'utiliser successiment ReadLn, très lourde à mon goût ?

Merci de votre aide

[Rayek]

Petite discussion d'il y a quelques temps déjà

http://www.developpez.net/forums/d35...ht=TStringList

[Keyem]

Merci pour ta réponse, je vais jeter un coup d'oeil !

[Keyem]

Petite discussion d'il y a quelques temps déjà

http://www.developpez.net/forums/d35...ht=TStringList

J'ai donc consulté ton archive. Mais toutes les solutions proposent de mémoriser chacune des lignes du fichier. Ceci n'est pas envisageable pour moi car les fichiers CSV sont trop gros.

N'existerait-il pas, tout simplement, une manière de faire pour que lors d'un ReadLn, on pointe non pas sur la ligne d'après, mais celle 10 lignes plus loin (par exemple) ?

[Rayek]

J'ai donc consulté ton archive. Mais toutes les solutions proposent de mémoriser chacune des lignes du fichier. Ceci n'est pas envisageable pour moi car les fichiers CSV sont trop gros.

N'existerait-il pas, tout simplement, une manière de faire pour que lors d'un ReadLn, on pointe non pas sur la ligne d'après, mais celle 10 lignes plus loin (par exemple) ?

Avec le ReadLn non, il lit ligne à ligne.
Si tes fichiers Csv sont avec des tailles fixes (Toutes les lignes on le même nombre de caractères) , tu pourrais le faire avec les TFileStream. (Seek pour positionner ou tu veux : Position + 10 x la taille d'une ligne)

Sinon, qu'est ce qui te gène au niveau du traitement ?
- La lenteur (combien de temps ?)
- La montée en mémoire ?
- etc ...

[Keyem]

Oui, mais cela implique t'il de mémoriser toutes les lignes du fichier avant ?

Mon soucis est que actuellement pour ignorer des lignes, j'utilise successivement des ReadLn.

Comme je charge plusieurs fichiers CSV, le traitement est très long et jaimerais gagner en temps.

En plus, je sais que mon application est deja très gourmande en mémoire, c'est pour cela que je ne peux pas me permettre d'enregistrer ligne par ligne mes fichiers.

[Rayek]

Oui, mais cela implique t'il de mémoriser toutes les lignes du fichier avant ?

Oui à quoi ?
Le TFileStream n'oblige pas à mémoriser les lignes en mémoires.

Mon soucis est que actuellement pour ignorer des lignes, j'utilise successivement des ReadLn.

Comme je charge plusieurs fichiers CSV, le traitement est très long et jaimerais gagner en temps.

En plus, je sais que mon application est deja très gourmande en mémoire, c'est pour cela que je ne peux pas me permettre d'enregistrer ligne par ligne mes fichiers.

Qu'est ce que tu appels gourmand en mémoire. J'ai des applications qui monte juste 1Go en mémoire et qui, une fois le traitement fini, retombe à 10-20Mo.

[e-ric]

Salut

Le fait que tu lises un fichier CSV t'oblige d'une façon ou d'une autre à lire toutes les lignes du fichier car la taille de la ligne est variable, ce qui in fine optimise la taille du fichier.

Ceci dit, lire une ligne ne veut pas dire la traiter. En utilisant un compteur allant cycliquement de 0 à 9, tu ne retiens que les lignes qui t'intéressent.

Si ton fichier avait une taille d'enregistrement fixe, un objet TFileStream t'aurait rendu service car tu aurais pu calculer les emplacements des données qui t'intéressent (réponse de Rayek).

Tu peux aussi simuler ReadLn avec TFileStream en recherchant les CR/LF pour extraire les lignes. L'avantage du TFileStream est que tu peux définir facilement la taille du tampon pour tes données, toutes les données n'y figurent pas. C'est une lecture par bloc de taille définie.

Quant à ton application, si effectivement elle consomme de la mémoire, cela se répercutera de toutes façons sur ton traitement car tu feras appel à la mémoire virtuelle. Il faut voir s'il n'y a pas moyen de réduire l'encombrement de ton application (ça peut cependant coûter cher en codage, tests, recette et compagnie), par exemple ne pas garder en mémoire les fiches qui ne sont pas utiles.

@+

[e-ric]

J'ai une solution en Delphi 7 + VCL standard donc pas de pb de compilation, normalement. Cela m'a permis de réviser un peu, j'ai créé une classe que l'on qualifier d'itérateur :

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
// Lignes indicées de 0 à LineRange-1
// sont retenues celles dont
  TStreamSlicer = class
  private
    FStream: TStream;       // le flux, donné par la pgm client 
    FLineNumber: Integer;   // Numéro de ligne courante
    FLinesRange: Integer;   // Portée (toutes les 10 lignes
    FLineRank: Integer;     // Rang de la ligne dans la portée
    FBuffer: String;        // Tampon pour la lecture du fichier
    FCursor: Integer;       // Position courante dans le tampon
    FEoS: Boolean;          // Indique la fin des données
  private
    procedure NextBuffer;
  public
    procedure Start(S: TStream; LinesRange, LineRank: Integer);
    function NextStr: String;
    property EoS: boolean read FEoS;
  End;
 
const
  CRLF = #13#10;

puis l'implémentation :

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
procedure TStreamSlicer.Start(S: TStream; LinesRange, LineRank: Integer);
begin
  if (LinesRange < 0) or (LineRank < 0) or (LinesRange <= LineRank) then
    raise Exception.Create('Spécifications numériques invalides');
  if not Assigned(S) then
    raise Exception.Create('Flux invalide');
  FLineRank := LineRank;
  FLinesRange := LinesRange;
  // Normaliser le rang des lignes à retenir, doit être compris entre 0 et LineRange - 1
  FLineRank := FLineRank mod FLinesRange;
  FStream := S;
  // Prendre le flux au début
  FStream.Seek(0, soFromBeginning);
  // Pas de ligne au départ
  FLineNumber := 0;
  NextBuffer;
End;
 
procedure TStreamSlicer.NextBuffer;
const
  BufSize = 4096; // octets dans le buffer
var
  NbRead: Integer;
begin
// Ces 3 instructions sont peut-être un peu consommatrice de CPU
// mais cela permet de travailler avec les fonctions Copy...
  SetLength(FBuffer, BufSize);
  NbRead := FStream.Read(FBuffer[1], BufSize);
  SetLength(FBuffer, NbRead);
  FCursor := 1;
  FEoS := NbRead = 0;
  if (not FEoS) and (FBuffer[NbRead] = #13) then
  begin
    // Reporte le CR à la prochaine lecture, en supprimant le CR final du buffer
    FBuffer := Copy(FBuffer, 1, BufSize-1);
    // Recule la position du flux sur le CR
    FStream.Position := FStream.Position - 1;
  end;
End;
 
function TStreamSlicer.NextStr: String;
var
  PosEOL : Integer;
  MoreLoop: Boolean;
begin
  Result := '';
  MoreLoop := True;
  while MoreLoop do
  begin
    PosEOL := PosEx(CRLF, FBuffer, FCursor);
    if (PosEOL > 0) and not EoS then
    begin
      // CR/LF trouvé
      if (FLineNumber mod FLinesRange) = FLineRank then
      begin
        // Limiter les mouvements de mémoire
        Result := Result + Copy(FBuffer, FCursor, PosEOL-FCursor);
        // Arrêt de la fonction pour restitution de la ligne
        MoreLoop := False;
      end;
      Inc(FLineNumber);
      // pour la ligne suivante (après le CR/LF)
      FCursor := PosEOL + 2;
    end
    else
    begin
      // on prend tout le buffer
      if (FLineNumber mod FLinesRange) = FLineRank then
        // Limiter les mouvements de mémoire
        Result := Result + Copy(FBuffer, FCursor, MaxInt);
      // et on passe au suivant, si possible
      MoreLoop := not EoS;
      if MoreLoop then
        NextBuffer
    end;
  end;
End;

Enfin un exemple :

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
procedure TForm1.Button1Click(Sender: TObject);
var
  F: TFileStream;
  Slicer: TStreamSlicer;
begin
  ListBox1.Clear;
  F := TFileStream.Create(ChangeFileExt(ParamStr(0), '.txt'), fmOpenRead);
  try
    Slicer := TStreamSlicer.Create;
    try
//      Slicer.Start(F, 1, 0); // toutes les lignes
//      Slicer.Start(F, 2, 0); // les  lignes paires
//      Slicer.Start(F, 2, 0); // les  lignes impaires
      Slicer.Start(F, 10, 0); // ligne 0, 10, 20 ...
//      Slicer.Start(F, 10, 1); // ligne 1, 11, 21 ...
      while not Slicer.EoS do
        ListBox1.Items.Add(Slicer.NextStr);
    finally
      Slicer.Free;
    end
  finally
    F.Free;
  end;
end;

Les quelques tests réalisés montrent que ça marche. Quant aux tests de performance, c'est pour ta pomme...

Tiens-moi au courant.

@+

[Keyem]

Merci e-ric pour ta solution j'ai pu la tester.
Ca marche niquel.
Cependant cette méthode remet en cause toute la structure existante du programme en terme de lecture de fichier.
Je ne pourais donc pas me pemettre toute cette modification (je suis en stage).
En tout les cas merci pour ta réponse, elle m'a été très instructive.

[e-ric]

Salut

Dommage que tu ne puisses pas t'en servir, il n'y pas moyen de l'adapter ?
Et du côté des performances, c'est ce que tu cherchais ?

@+