Bonsoir les amis,
 
Une question me taraude  
 
J'ai une procédure qui créée un fichier en lisant un autre fichier. Ceux-ci sont généralement de grande tailles (> 100 Mo). La question que je me pose est la suivante :
 
jusqu'à présent, je faisais un truc dans ce genre :
 
1. Créer le fichier Destination,
2. Ecrire 15 Mo de données depuis Source vers Destination,
3. Fermer Source et Destination.
 
Donc en fait, mon fichier est créé par bloc de 15 Mo.  
 
En lisant quelques codes sources sur le net, j'ai remarqué que beaucoup (une majorité) effectuaient l'opération d'écriture par paquet de 8 ko ou 16ko dans une boucle Tant Que. Cela leur permet d'avoir une visualation précise de l'état d'avancement de la création du fichier.
 
Concrètement, est-il plus intéressant (optimisation) d'écrire les données d'un fichier par paquet à l'aide d'une boucle ou alors de faire un truc direct du genre DestinationStream.CopyFrom(SourceStream, 15000000);
 
Moi j'utilise la 2ème méthode et donc la progression indiquant la création du fichier s'effectue par bloc de 15 Mo et donc ça fait des gros jump du style 2%...20%...33%...41%...etc.  
 
Si un épai brouillard se trouve entre mon post et vos yeux et que vous n'avez rien compris, dites-moi, j'ai les feux anti-brouillard, j'éclairerai votre route.
 
Merci à vous.

À mon avis ça ne change pas grand chose aux perfs, par contre ce que tu peux faire c'est donner au stream de destination la taille finale (Dest.Size := Source.Size) avant de copier, puis ensuite revenir au début du fichier et faire la copie.
Ça évite la fragmentation en NTFS (mais il faut vérifier qu'en FAT32 il ne fasse pas l'andouille en voulant remplir le fichier de vide...)

ouep g fait des tests et la durée de l'opération est très sensiblement la même. La seule différence, c'est qu'avec un petit buffer la visualisation de la progression est très précise. J'ai choisi 64 ko comme buffer, c ni trop gros ni trop petit et ça marche plutôt bien.
 
Mais maintenant un autre problème me chiffonne.
 

 
Mr Delphi ne veut pas compiler et me dit ceci :
 

 
J'ai essayé de mettre les 2 en Shortstring, marche pas, les deux en String[17], marche encore moins
 
Lé où l'erreur ?  

Tu mets bêtement string et ça doit passer.
Je vois pas l'intérêt d'utiliser des ShortString à part pour des records de taille fixe.
(ShortString = chaîne de longueur fixe comme dans les vieilles versions de Pascal)
 
Normalement on écrit "string" et non pas "String", string étant un mot-clé alors que Integer par exemple est un type (d'ailleurs string s'affiche en gras). Dans Delphi le mot-clé string désigne par défaut une AnsiString.
Même si c'est pas case-sensitive, il y a des conventions d'écriture
http://community.borland.com/artic [...] 80,00.html

oui c'est bien ça, il me faut uniquement 17 caractères

Il te faut 17 caractères, mais tu t'en fous que ta classe prenne 17 ou 21 octets en mémoire
Avec les property à mon avis tu pourras pas jouer avec les ShortString à moins de définir un type pour une ShortString de longueur 17.
Ce qui est un peu tordu.
Comme je l'ai dit à moins de les utiliser dans des record qui doivent avoir une taille fixe et pas de pointeur (par ex parce qu'ils sont balancés tel quels en mémoire ou sur le disque), on n'utilise pas les ShortString.
Si jamais tu veux être sûr que ta chaîne ait moins de 17 caractères, tu mets un SetLogiciel dans le write de ta property, et dans ce SetLogiciel tu mets :
 
FLogiciel := Copy(Value, 1, 17);
(Value étant le param reçu par la fonction).

Oui c'est exactement ce que j'étais en train de faire en fait
 
je bricole, je bricole

Je voudrai savoir un autre petit truc. Je voudrai savoir quelle est la taille optimale d'un buffer pour écrire un flux de données dans un fichier. Je sais pas quoi mettre comme valeur, 1 ko, 32 ko, 1 Mo ? C'est quoi la meilleure taille si on souhaite écrire des fichiers de plusieurs dizaine de Mo ?
 
Pour l'instant j'ai choisi 64 ko mais vraiment au hasard.
 
Merci :-)

Ça je ne sais pas. De toute façon le TFileStream va le découper en blocs je pense.
Vu la vitesse d'écriture de 64 Ko, tu risques de ralentir la copie parce que ça rafraichira trop souvent l'affichage. Si tu fais des blocs de 256 Ko par exemple (ou même 512 Ko, voire 1 Mo) ça ira tout aussi bien je pense.

je vais faire des tests avec toutes ces valeurs
 
Merki.

Yop, nouvelle question
 
Je bloque là pour déterminer la vitesse à laquelle sont écrites les données du flux en Mo.
 
J'ai pensé à un truc du genre :
 
vitesse = taille données écrites / temps d'exécution en seconde
 
Normalement je devrai avoir le nombre de MO écrit en 1 seconde non ? ze sais pas trop

oui, si tu fournis la taille en Mo

finalement g trouvé + simple, je sais pas si c mieux mais en tout cas ça marche
 
vitesse = Données écrites en Mo actuel - Données écrites en Mo il y'a 1 sec
 
et voilu