CodeGym /Corsi /C# SELF /Formati di file: Testuali e Binari

Formati di file: Testuali e Binari

C# SELF
Livello 35, Lezione 1
Disponibile

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
Esempio di contenuto di books.txt (formato CSV)

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.

2
Compito
C# SELF, livello 35, lezione 1
Bloccato
Scrittura e lettura di un file di testo
Scrittura e lettura di un file di testo
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION