1. File testuali
Ricorda: il computer memorizza tutto, proprio tutto, come uno e zeri (o, se non hai paura di parole grosse — come una sequenza di byte). Ma se dai lo stesso file a due programmi diversi, non è detto che lo vedano allo stesso modo. Magari uno vede del testo normale, l'altro — una serie di "byte rotti". Tutto dipende dal formato del file — cioè, come vengono interpretati questi byte. Il formato descrive la struttura interna dei dati, le regole di lettura e la codifica. Senza conoscere il formato, il programma potrebbe non capire cosa c'è nel file.
Un file testuale è un file in cui i dati sono rappresentati come testo normale in una qualche codifica (di solito — UTF-8 o, se vuoi fare il duro — ASCII). Il contenuto di un file così lo puoi aprire con qualsiasi editor di testo (tipo Notepad o VS Code) e leggerlo subito — sono stringhe di caratteri, non strani byte di controllo o strutture binarie.
Esempi tipici
- *.txt — file di testo normali, tipo "to-do.txt" o "best-books.txt".
- *.csv — file dove i dati sono separati da virgole o punti e virgola (comodissimo per tabelle).
- *.json — file per scambiare dati strutturati (tipo liste di libri).
- *.xml,*.html — per salvare e trasmettere dati strutturati.
Esempio di file CSV
Dune;Frank Herbert;1965
1984;George Orwell;1949
Il Maestro e Margherita;Mikhail Bulgakov;1966
Ogni riga è una voce separata (tipo un libro). I valori nella riga sono separati da punto e virgola, quindi il file è un esempio di CSV (Comma-Separated Values). Comma sarebbe la virgola, ma qui il separatore è diverso (;). I simboli che vede l'umano sono gli stessi byte che legge il programma, a patto che sappia come interpretare il formato testuale e la codifica del file.
Come lavora un programma con un file testuale
Basta aprire il file "come testo" e puoi leggerlo riga per riga. Esempio (che ti servirà nelle prossime lezioni):
// Lettura semplice delle righe da un file (i dettagli li vediamo presto)
string[] lines = File.ReadAllLines("books.txt");
foreach (string line in lines)
{
Console.WriteLine(line);
}
Vantaggi dei file testuali
- Leggibili dall'umano (human-readable).
- Facili da modificare a mano (anche con Notepad o roba simile).
- Perfetti per il debug e lo scambio tra sistemi diversi.
- Facili da spostare tra piattaforme diverse (Windows, Linux, Mac).
Svantaggi dei file testuali
- Nessuna struttura rigida (txt), è facile fare errori di formattazione per sbaglio.
- Occupano più spazio (tipo il numero 12345 = 5 byte, mentre in binario — 4).
- Dati complessi (tipo immagini, audio) sono scomodi o impossibili da passare come testo.
- Performance: più lenti con grandi quantità di dati.
Cose utili da sapere
- Piattaforme diverse capiscono "fine riga" in modo diverso: Windows — \r\n, Unix — \n.
- Le codifiche possono cambiare (UTF-8, UTF-16, ANSI ecc.), quindi un file scritto su un sistema può sembrare "cinese" su un altro (in realtà è solo interpretazione sbagliata dei byte).
2. File binari
Un file binario è un file dove dentro ci sono byte a caso, non caratteri. Possono essere qualsiasi cosa: numeri, strutture, immagini, musica, anche codice macchina. Prova ad aprire un .exe con Notepad — vedrai solo roba incomprensibile!
Esempi tipici
- *.exe, *.dll — file eseguibili e librerie.
- *.jpg, *.png, *.gif— immagini.
- *.mp3, *.wav— file audio.
- *.dat — file con dati utente a caso.
- Formati specifici per applicazioni (*.docx, *.xlsx ecc.) — quasi sempre binari.
Com'è fatto un file binario?
Byte dopo byte, il programma scrive e legge i dati nel formato che gli serve. Per esempio, un numero tipo int viene scritto in 4 byte (32 bit), una stringa — di solito è lunghezza + i byte dei caratteri in una certa codifica.
In un file testuale il numero 12345 sono i byte dei caratteri '1', '2', '3', '4', '5':
| Carattere | Codice UTF-8 |
|---|---|
| 1 | 49 |
| 2 | 50 |
| 3 | 51 |
| 4 | 52 |
| 5 | 53 |
In un file binario int 12345 (ordine dei byte piccolo, little-endian) sarà così:
| Posizione | Byte (hex) | Valore |
|---|---|---|
| 0 | 0x39 | 57 |
| 1 | 0x30 | 48 |
| 2 | 0x00 | 0 |
| 3 | 0x00 | 0 |
(In altre parole: 12345 = 0x00003039.)
Prova a scrivere lo stesso numero in testo e in binario — e confronta la dimensione dei file. Quello binario sarà un po' più compatto.
Come lavora un programma con un file binario
Stream speciali (tipo BinaryReader, BinaryWriter). Diversamente dal file testuale, devi sapere esattamente la struttura, altrimenti non riesci a leggere i dati.
// Esempio di scrittura di numeri in un file binario
var writer = new BinaryWriter(File.Open("books.bin", FileMode.Create));
// Mettiamo che scriviamo la codifica: numero di caratteri (int), poi i byte
string title = "Dune";
writer.Write(title.Length); // Scriviamo la lunghezza (int)
writer.Write(title); // Scriviamo la stringa (sarà in UTF-8)
writer.Write(1965); // Scriviamo l'anno (int)
writer.Close(); // chiudiamo lo stream
Questo è solo un esempio. Ti spiegherò meglio come lavorare con i file binari nelle prossime lezioni.
Vantaggi dei file binari
- Compatti: occupano meno spazio.
- Più veloci da leggere e scrivere (soprattutto con tanti dati).
- Puoi salvare strutture complesse: array, oggetti annidati ecc.
Svantaggi dei file binari
- Non leggibili dall'umano (human-unreadable).
- Se la struttura del file cambia, i vecchi dati possono andare persi o "rompersi".
- Servono sempre istruzioni precise per capire il contenuto.
3. Quale formato scegliere?
File testuali vs File binari
| Criterio | File testuale | File binario |
|---|---|---|
| Leggibile dall'umano | Sì | No |
| Dimensione | Più grande | Più piccolo |
| Universalità | Alta (qualsiasi editor) | Solo programmi speciali |
| Velocità | Più lento | Più veloce |
| Rigidità del formato | No | Sì, da rispettare |
| Salvataggio strutture | Difficile | Facile |
| Rischio di corruzione dati | Basso (facile da correggere) | Alto (basta poco e il file non si legge più) |
Criteri di scelta
- Vuoi che i dati siano leggibili dall'umano, facili da modificare e da debuggare? — Usa un file testuale (tipo .txt, .csv, .json).
- I dati sono complessi, contano dimensione e velocità? — Formato binario.
- Devi scambiare dati tra piattaforme diverse? — Meglio il testo, ma la codifica deve essere standard (UTF-8).
- L'app deve leggere e scrivere tanti dati, e il formato è rigido? — Scegli il binario.
Nella nostra app console "Lista libri" all'inizio va benissimo il formato testuale (.csv o .txt). Più avanti, se la struttura si complica o vuoi più velocità, puoi studiare i file binari o passare a JSON/XML.
4. Sfumature utili
Dove si trovano file testuali e binari nella vita reale?
File testuali:
- Impostazioni dei programmi (spesso in .ini o .json).
- Script, log, note.
- File di import/export (dati per scambio tra app).
File binari:
- Programmi, giochi, librerie (nessuno ci mette il naso così).
- Grandi database e archivi (tipo .mdb, .zip).
- Media: musica, foto, video.
Lettura di tutto il file in una volta (testo):
string allText = File.ReadAllText("books.txt");
// Ora allText è una mega stringa con tutto il contenuto
Per righe (ottimo per le liste):
string[] lines = File.ReadAllLines("books.txt");
foreach (string line in lines)
{
// Puoi dividere la riga in parti
string[] parts = line.Split(';');
// parts[0] — titolo, parts[1] — autore, parts[2] — anno
}
Lettura binaria — solo seguendo la struttura
var reader = new BinaryReader(File.Open("books.bin", FileMode.Open));
int count = reader.ReadInt32(); // Quanti libri
for (int i = 0; i < count; i++)
{
string title = reader.ReadString();
string author = reader.ReadString();
int year = reader.ReadInt32();
// Ora puoi ricostruire la voce!
}
reader.Close();
5. Esempio pratico: creiamo un file con i libri
Salviamo i dati in un file testuale
Salveremo ogni libro in una riga così:
titolo;autore;anno della prima edizione
// Lista di libri che vogliamo salvare
var books = new List<(string Title, string Author, int Year)>
{
("Dune", "Frank Herbert", 1965),
("1984", "George Orwell", 1949),
("Il Maestro e Margherita", "Mikhail Bulgakov", 1966)
};
// Salviamo in un file di testo
var writer = new StreamWriter("books.txt");
foreach (var book in books)
writer.WriteLine($"{book.Title};{book.Author};{book.Year}");
writer.Close();
Puoi aprire books.txt con Notepad e vedere tutti i dati.
Salviamo i dati in un file binario
Ora proviamo la stessa cosa, ma più compatta (anche se illeggibile per l'umano):
var writer = new BinaryWriter(File.Open("books.bin", FileMode.Create));
writer.Write(books.Count); // Scriviamo il numero di libri
foreach (var book in books)
{
writer.Write(book.Title); // Stringa - sarà salvata come: lunghezza + byte
writer.Write(book.Author); // Stringa
writer.Write(book.Year); // Anno (int)
}
writer.Close();
Se provi ad aprire books.bin con un editor di testo, vedrai solo caos: simboli incomprensibili. È normale. I file binari non sono fatti per essere letti dall'umano — solo un programma che sa esattamente come è stato scritto può leggerli giusti.
6. Errori tipici con i formati
Se provi a leggere un file binario come se fosse testo, ottieni solo "pappa" di simboli o addirittura un errore. Allo stesso modo, se apri un file di testo come binario e ti aspetti una struttura precisa — avrai problemi.
L'errore più comune: non rispettare la struttura dei dati e l'ordine di lettura/scrittura. Tipo: prima hai scritto l'anno, poi il titolo, ma leggi al contrario — ottieni dati sbagliati. Rispetta sempre lo stesso ordine di operazioni!
Spesso i programmatori "sbirciano" nei file di testo per controllare la logica di salvataggio e caricamento — proprio per questo i formati testuali sono comodi all'inizio. Il binario invece va bene per scenari avanzati, o quando vuoi nascondere i dettagli di salvataggio all'utente.
GO TO FULL VERSION