| Guide e Tutorials:indexed | |||||||||||||||||||||||||||
| Studio sui file binari (Prima parte) - definizione ed accesso in lettura e scrittura All'interno di questo studio, suddiviso in più parti, si potrà approfondire le caratteristiche dei file binari, dalla definizione e dai metodi di accesso in scrittura e lettura di variabili numeriche e di testo trattati in questo articolo, all'immissione ed estrazione di dati diversi come Variant, tipi definiti dagli utenti, matrici, per finire col recupero di file binari (principalmente file di testo e immagini) da Internet, facendo uso del controllo Winsock. La definizione di file binario è stata in parte già trattata nel corso di Visual Basic di Giorgio Abraini. In questi articoli di approfondimento cercheremo di andare più nel dettaglio, analizzando varie operazioni che possono essere compiuti su tali file. In sostanza un file binario è un file il cui contenuto dev'essere necessariamente interpretato da un'applicazione oppure da una periferica hardware che siano predisposte a decodificare la sequenza di caratteri che compone un file binario. Se infatti provassimo ad aprire un tipico file binario, un'immagine di qualsiasi formato, con un editor di testo, ci troveremmo davanti ad una serie di caratteri difficilmente interpretabile. La figura qua sotto mostra il contenuto di un file binario così come visualizzato da un editor di testo:  Tra i vari tipi di file binari possiamo trovare gli eseguibili (con estensione .exe), i file di database, quelli creati da fogli elettronici e così via. Naturalmente non esiste alcuna lista dei vari tipi di files binari esistenti siccome ognuno può creare un file binario ed assegnargli l'estensione desiderata. Questo perchè non è l'estensione che crea il file binario ma quello che esso contiene. Gestire un file binario (nella lettura e nella scrittura) può risultare scomodo in quanto scrivere e leggere i byte uno ad uno non è troppo agevole. In ogni caso l'utilizzo di tali files ha diversi punti a suo favore. Primo: la possibilità di trasmettere dati in blocco. Facciamo un esempio: nell'invio di un allegato sotto forma di file binario per posta elettronica, non è necessario cercare di leggere o modificare i dati che esso contiene: ci si può semplicemente limitare ad trasmettere un intero blocco di 0 e di 1, il cui significato è sconosciuto finchè il destinatario dell'allegato non attiva un'applicazione che li interpreti. Secondo: la possibilità di creare formati di files personalizzati. Se ad esempio abbiamo sviluppato l'applicazione denominata WinCrashesTwiceADay, possiamo ragionevolmente decidere di creare files di estensione .WCT (WinCrashesTwiceADay) che verranno letti solamente dall'applicazione da noi creata. Quasiasi tentativo di utilizzo tramite altro programma causerà un errore. A questo punto chiediamoci: come scrivere e leggere un file binario? Innanzitutto è necessaria una piccola parentesi, nella quale ci si deve riferire brevemente ai metodi di scrittura su file supportati da Visual Basic. In breve, si utilizza l'istruzione Open per dichiarare di voler aprire un file per operare con i dati in esso contenuti. Operazione che può essere di scrittura o lettura. Questo l'istruzione Open non lo indica. Per specificare la modalità di accesso al file, ossia il criterio col quale i dati verranno manipolati, si utilizzano le parole chiave Append, Binary, Input, Output o Random. Le operazioni da compiere sui dati del file sono invece specificate dalle parole chiave Read, Write o Read Write. Ad esempio il codice seguente il file fly.WCT in modalità input sequenziale:
Una volta terminata questa premessa vediamo come poter scrivere all'interno di un file binario. Sarà innanzitutto necessario utilizzare l'istruzione Put. Per utilizzare tale istruzione è necessario specificare la seguente sintassi:
dove numeroFile è il numero del file aperto attraverso l'istuzione Open. Avevamo infatti indicato nel codice sopra:
numeroByte indica invece la posizione nella quale si desidera cominciare a scrivere il all'interno del file. Se infatti si prende come riferimento l'immagine mostrata all'inizio dell'articolo, sarebbe molto difficoltoso indicare all'applicazione che stiamo sviluppando dove inserire un dato senza indicare la posizione del carattere dal quale partire. Infatti immaginiamo di avere un file contenente una serie di byte che formino la parola 'dente'. Vogliamo inserire le lettere 'a', 'l' in modo da ottenere 'dentale'. Tenendo conto che il primo byte di un file si trova nella posizione 1, il secondo nella posizione 2 e così via, ecco come dovremo scrivere sul file:  l'ultimo parametro richiesto dalla sintassi di Put ossia nomeVariabile indica il nome della variabile contenente i dati da scrivere. E' necessario sottolineare che sia nella lettura che nella scrittura in files binari non è assolutamente richiesto specificare la lunghezza di tale variabile nonchè il suo tipo (Integer, String o quant'altro). Quest'operazione viene infatti eseguita quando impostiamo la lunghezza di nomeVariabile, sia al momento della lettura che a quello della scrittura. Quali sono le modalità di accesso ai file binari? Abbiamo già visto i metodi generali (Append, Binary, Input, Output o Random). Per riferirsi ad un file binario si dovrà necessariamente utilizzare Binary che indica all'applicazione che sta per avere a che fare con un file di tipo binario. Le operazioni sono le stesse di tutti gli altri tipi di file esclusa la possibilità di prevenire la lettura e la scrittura del file: per leggere un file binario si usa Read mentre per scriverlo si usa Write. Per bloccare l'accesso di un'altra applicazione, come si diceva prima, bisogna inserire Lock Read Write. Quindi se ad esempio volessimo scrivere nel primo byte il numero 2500, dovremo operare in questo modo:
mentre se volessimo eseguire la stessa operazione utilizzando Lock Read Write, il codice diventerebbe:
A questo punto come facciamo a recuperare le informazioni contenute nel file? Con l'istruzione Get che ha la medesima sintassi di Put ossia:
Per recuperare il dato 2500 immesso nel file dal codice precedente, dobbiamo innanzitutto specificare che tipo di dato stiamo per recuperare. Ecco il codice completo per l'operazione di lettura:
dalla finestra di messaggio dovrebbe apparire il numero che avevamo immesso nel file ossia 2500. Se si prova a modificare il numero inserito (ad esempio 1000 invece di 2500), si nota che il dato viene sovrascritto (in posizione 1 in questo caso) e non inserito come ultimo dato come accade nei semplici file di testo. Per quanto riguarda invece i dati in formato testuale, le cose variano leggermente in quanto sarà necessario indicare la lunghezza dei dati da leggere. Così se nel blocco di codice per la scrittura nei file binari, inseriamo invece di 2500 il dato "duemilacinquecento", in questo modo:
dobbiamo conoscere necessariamente la lunghezza del dato che stiamo per estrarre. Quindi nel caso della stringa di testo "duemilacinquecento" sarà necessario indicare che si tratta di una stringa di lunghezza 18. E del resto l'istruzione Get non prevede un parametro che indichi la lunghezza del dato da recuperare (mentre in Put questo procedimento è implicito perchè inserire il dato "duemilacinquecento" significa inserire una variabile di lunghezza 18). Se infatti si prova a recuperare la variabile-stringa "duemilacinquecento" attraverso il codice seguente (che non fa altro che modificare il tipo di variabile nel quale sarà archiviato il dato: Integer prima e String adesso):
si otterrebbe una finestra di messaggio del tipo:  che mostra la stringa vuota "" (lunghezza 0). Come fare allora per avvisare l'applicazione di quanto lungo dev'essere il dato che vogliamo estrarre? Semplicemente inizializzando la variabile-stringa nomeVariabile, indicando ad essa la lunghezza del dato:
dove la funzione Space restituisce un valore sotto forma di stringa di testo costituito dal numero specificato di spazi. Proviamo adesso utilizzando la funzione Space nel seguente modo:
ecco cosa visualizzerà questa volta la finestra di messaggio:  ma nulla c'impedisce di limitarci a recuperare solo parte della stringa, indicando come lunghezza di nomeVariabile 9 invece di 18:
Ecco il risultato di questo esperimento:  Certo questo metodo non è esente da obiezioni. Prima fra tutte l'impossibilità di essere utilizzato nei casi in cui non si conosce per niente la lunghezza del dato da recuperare, ad esempio perchè stiamo leggendo un file binario creato da terzi. Questo inconvieniente può essere bypassato con un metodo artigianale ma molto efficace: scrivendo la lunghezza della stringa nel file, ancora prima della stringa stessa. Se consideriamo allora un'altra variabile di tipo Integer denominata LunghDato nella quale viene archiviata tale lunghezza della variabile stringa Dato, possiamo scrivere:
Per recuperare finalmente la variabile che ipotizziamo non conoscere affatto, dobbiamo procedere in senso contrario ossia recuperando la lunghezza della stringa prima e poi il suo contenuto poi, proprio come mostrato sotto:
Anche in questo caso il risultato sarà:
| |||||||||||||||||||||||||||