Newsgroup: it.comp.lang.visual-basic
Titolo: Solo Esperti

Non fate caso all'oggetto del messaggio è solo per attirare
l'attenzione......
Comunque vorrei sapere se è possibile creare un file unico da più
file(semmai "incollandoli") e scompattarne uno alla volta quando serve
nella directory temporanea????
please anche in e-mail
            Salutoni Antonello
      mailto:
a.al...@mail.omnitel.it

...

in quanto a scompattarli uno alla volta non saprei, ma perchè non usi
semplicemente pkzip?

no
Come "no"?
Basta codtruirsi un'header con le info dei files incollati (nome,
dimensioni) e incollarlo anch'esso ai files tutti incollati a loro volta.
Per incollare un files basta leggerlo come array di bytes con la Get e poi
fare un Put dello stesso array alla fine del file totale (Seek #file,
LOF(#file)+1)).
Ciao.


E' chiaramente possibile ma piuttosto complicato.
Dovresti aprire sia i files da riunire che quello unico, in modo BINARIO.
Crearti un piccolo file contenente le posizioni dei files una volta inseriti
nel file che li comprende tutti (una specie di FAT) e il gioco é fatto.
Se sei in vena di sofisticazioni la tua FAT potrebbe risiedere all'inizio
del file "contenitore".
E' piuttosto complicato da spiegare qui, ma se pó ffá.
Ciao,
Dads

nella directory temporanea????
Si, è possibilissimo... è quello che fanno in pratica iprogrammi tipo pkzip
(in più loro ci mettono anche un algoritmo di compressione, of course...
^_^)
Devi quindi creare un file strutturato.
Public Type MYFILEHEADER
    Name As String*255
    Offset As Long
    Lenght As Long
End Type
Questa struttura è in grado di conservare le informazioni necessarie per
recuperare il file. In pratica la struttura del file archivio che andrai a
creare dall'unione di tanti file sarà:
- 2 byte (iArchives As Integer) : numero di files contenuti nell'archivio
(penso che 65536 bastino, no ?  ^_^)
- 263 byte * iArchives (strutture MYFILEHEADER, una per ogni file
archiviato)
- altri byte (il corpo dei files archiviati)
ATTENZIONE: in questi esempi i file vanno aperti tutti in modo binario,
quindi si utilizzeranno, per leggere e per scrivere, le funzioni GET e PUT.
In questo modo diventa facile scrivere il file:
1- Aprire il file archivio
2- Calcolare il numero dei file da inserire e si scrive nel file archivio il
primo valore.
3-  Creare un vettore di strutture MYFILEHEADER necessarie per immagazzinare
le informazioni sui files.
4-  Spostarsi alla posizione in cui si deve inserire il corpo del primo file
(al byte numero: 2+263 * iArchives+1).
5-  Aprire il primo file da archiviare e si riempie la relativa struttura
con:
        .Name : il nome del file (max 255 caratteri)
        .Offset : la posizione che assumerà il corpo del file nel file
archivio (si usa la funzione LOF applicata al file archivio)
        .Lenght : la lunghezza del file da archiviare
6- Copiare pari pari i byte del file da archiviare nel file archivio e si
chiude il primo file.
7- Ripetere dal punto 5 per ogni file da archiviare
8- Dopo che tutti i corpi dei files sono stati inseriti, si esegue in ciclo
per inserire le strutture MYFILEHEADER nel file archivio, partendo dal byte
numero 3 (i primi 2 byte sono già riservati, ricordate? ^_^)
9- Chiudere il file archivio
Per estrarre un file dal file archivio si deve fare così:
1- Individuare il file da estrarre (ci sono tanti modi... se conosciamo già
la sua posizione si fa prima, cmq nulla ci vieta di iterare tra tutte le
proprietà .Name che abbiamo inserito nel file archivio, per cercare un file
dal nome specifico). Poniamo che vogliamo recuperare il file n°3.
2- Aprire il file archivio e spostarsi nella posizione in cui si trova la
struttura MYFILEHEADER del file che vogliamo recuperare. (nel nostro esempio
questa struttura si troverà al byte numero 2+263*3+1)
Per spostarsi, in un file binario, si deve usare SEEK.
3- Leggere la struttura
4- Spostarsi al byte specificato dalla proprietà .Offset
5- Aprire un file in modalità binaria dandogli come nome la proprietà .Name
della struttura letta in precedenza.
6- Copiare un numero di byte pari alla proprietà .Lenght dal file archivio
7- Chiudere entrambi i files. Ora il file desiderato è stato estratto e
ricostruito esattamente come era all'origine.
-------------------------------------------------------
Volendo è poi possibile migliorare la gestione del file sostituendo i 2 byte
iniziali con una struttura di questo tipo (30 byte):
Public Type MYARCHIVEHEADER
       tChunk As String * 4
       vChunk As String * 4
       Size As Long
       Reserved1 As Long
       Reserved2 As Long
       Reserved3 As Long
       Reserved4 As Long
       Archives As Integer
End Type
- Il campo tChunk si userebbe per identificare in modo univoco il file,
assegnandogli un valore fisso (Es: "MYAR" - se il file ha un campo tChunck
diverso da "MYAR", allora non è un file archivio valido)
- Il campo vChunk si userebbe per identificare la versione del programma che
ha creato il file (Es: "0010" per la versione 1.0, "0022" per la versione
2.2, ecc...)
- Il campo Size si userebbe per controllare la lunghezza complessiva del
file, se il file ha una lunghezza diversa da quanto scritto nel campo Size,
allora o è stato modificato impropriamente, oppure è danneggiato. (Un
controllo sul CRC sarebbe migliore, ma forse è un po' esagerato per questo
tipo di applicazioni)
- I campi ReservedX sono riservati ad usi futuri (non si sa mai ^_^)
- Il campo Archives verrebbe usato al posto della variabile iArchives usata
in precedenza per immaggazzinare il numero totale di file contenuti
nell'archivio.
Con una struttura del genere occorre modificare pure i valori descritti
prima:
2+263 * iArchives+1  >>diventa>>   30+263 * .Archives+1
-----------------------------
Se qualcosa non ti è chiaro manda pure un'altro messaggio, cmq ti assicuro
che più facile da fare che non da spiegare ! ^____^
Bye ! ^_-
Zeross

cIAO zEROS !