1. Introduzione
Abbiamo già familiarità con i flussi (Stream), che sono un'astrazione per la lettura o la scrittura sequenziale dei dati. Abbiamo lavorato con FileStream per accedere ai file a livello di byte, e abbiamo anche usato StreamReader e StreamWriter per lavorare comodamente con i dati di testo, che sotto il cofano usano FileStream e si occupano delle codifiche.
Ma cosa succede se dobbiamo salvare in un file non solo testo, ma dati fortemente tipizzati: numeri interi (int), numeri floating point (double, float), valori booleani (bool), date (DateTime) o anche strutture custom? Certo, potresti convertire tutto in stringhe e scrivere usando StreamWriter, per poi fare il parsing al momento della lettura. Però questo approccio ha dei grossi svantaggi:
- Inefficienza di storage: Il numero 12345 scritto come testo occupa 5 byte (caratteri). In binario, un int occupa solo 4 byte. Su grandi quantità di dati la differenza è enorme.
- Performance: Convertire continuamente numeri in stringhe e viceversa è un overhead per la CPU.
- Precisione dei dati: Convertire numeri floating point in testo e poi di nuovo può portare a perdita di precisione per via degli arrotondamenti.
- Parsing complicato: Smontare manualmente stringhe di testo per estrarre diversi tipi di dati (tipo "123,45 TRUE 2024-06-21") complica parecchio il codice e lo rende fragile.
Per risolvere questi problemi esistono le classi specializzate BinaryReader e BinaryWriter. Queste classi sono degli adapter specializzati che lavorano sopra qualsiasi Stream di base (di solito FileStream) e ti danno metodi comodi per leggere e scrivere tipi primitivi di C# nel loro formato binario. Si occupano loro di convertire i byte nei tipi giusti e viceversa, semplificando di molto il lavoro con file binari strutturati.
Idea chiave: BinaryReader e BinaryWriter non sono flussi a sé stanti. Potenziano la funzionalità di uno Stream esistente, aggiungendo metodi per lavorare con i tipi C# invece che con i byte grezzi.
2. Scrivere dati con BinaryWriter
BinaryWriter offre una serie di metodi Write(), overloadati per ogni tipo primitivo di C#. Quando chiami uno di questi metodi, BinaryWriter converte il valore nella sua rappresentazione binaria (una sequenza di byte) e scrive questi byte nello Stream di base.
Esempio: Salviamo le impostazioni di un gioco
Immagina di voler salvare le impostazioni di un gioco: livello del volume (numero floating point), livello attuale del giocatore (intero), se la musica è attiva (booleano) e il livello di difficoltà scelto (stringa).
string filePath = "settings.bin";
// 1. Creiamo un FileStream per la scrittura
using FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write);
// 2. Creiamo un BinaryWriter sopra il FileStream, specificando la codifica per le stringhe (se ci sono)
using BinaryWriter writer = new BinaryWriter(fs, Encoding.UTF8);
// 3. Scriviamo diversi tipi di dati
writer.Write(0.75f); // float (4 byte)
writer.Write(15); // int (4 byte)
writer.Write(true); // bool (1 byte)
writer.Write("Easy"); // string (prefisso lunghezza + byte)
Console.WriteLine($"Impostazioni salvate in '{filePath}'.");
Analisi dell'esempio:
- Creiamo un FileStream con FileMode.Create, che crea un nuovo file o sovrascrive quello esistente.
- Poi creiamo un BinaryWriter, passandogli fs. Occhio che BinaryWriter di default chiude lo stream di base (fs) quando chiami Dispose() (che viene chiamato automaticamente dal blocco using).
- I metodi writer.Write() sono super intuitivi: Write(float), Write(int), Write(bool), Write(string). Sanno già loro quanti byte scrivere per ogni tipo e come rappresentarli.
- Per le stringhe BinaryWriter aggiunge automaticamente un prefisso di lunghezza prima dei byte della stringa. Così BinaryReader sa esattamente quanti byte leggere per ricostruire la stringa.
- Se provi ad aprire settings.bin in un editor di testo vedrai solo "spazzatura", perché è un file binario. Per vedere il contenuto serve un editor HEX.
3. Leggere dati con BinaryReader
BinaryReader offre metodi ReadXxx() (tipo ReadInt32(), ReadBoolean(), ReadString()), che leggono il giusto numero di byte dallo Stream di base e li convertono nel tipo di dato C# richiesto.
Esempio: Carichiamo le impostazioni del gioco
Ora leggiamo le impostazioni dal file settings.bin che abbiamo creato prima.
string filePath = "settings.bin";
// 1. Creiamo un FileStream per la lettura
using FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
// 2. Creiamo un BinaryReader sopra il FileStream, usando la stessa codifica
using BinaryReader reader = new BinaryReader(fs, Encoding.UTF8);
// 3. Leggiamo i dati NELLO STESSO ORDINE in cui sono stati scritti
float volume = reader.ReadSingle(); // float
int level = reader.ReadInt32(); // int
bool isMusicOn = reader.ReadBoolean(); // bool
string difficulty = reader.ReadString(); // string
Console.WriteLine($"Impostazioni caricate da '{filePath}':");
Console.WriteLine($"- Volume: {volume:P0}"); // Formattiamo come percentuale (usando string formatting)
Console.WriteLine($"- Livello giocatore: {level}");
Console.WriteLine($"- Musica attiva: {isMusicOn}");
Console.WriteLine($"- Difficoltà: {difficulty}");
Analisi dell'esempio:
- Apro un FileStream in modalità FileMode.Open per la lettura.
- Creo un BinaryReader sopra fs, specificando la stessa codifica usata in scrittura.
- Fondamentale: L'ordine delle chiamate ai metodi reader.ReadXxx() deve ESSERE ESATTAMENTE LO STESSO dell'ordine in cui i dati sono stati scritti con BinaryWriter. Se provi a leggere una string dove era stato scritto un int, otterrai un errore EndOfStreamException (se la string è più lunga) o leggerai dati sbagliati.
- I metodi ReadXxx() leggono automaticamente il numero giusto di byte e li convertono nel tipo richiesto. ReadString() usa proprio quel prefisso di lunghezza scritto da BinaryWriter per sapere quanti byte leggere per la stringa completa.
4. Sfumature importanti e best practice
Ordine rigoroso:
Questa è la regola principale. BinaryReader e BinaryWriter non salvano metadati sui tipi; sanno solo quanti byte occupa ogni tipo primitivo. Devi assicurarti tu che l'ordine corrisponda.
Gestione delle risorse (using):
Come la maggior parte delle classi .NET che lavorano con risorse di sistema (tipo file o connessioni di rete), sia BinaryReader che BinaryWriter implementano l'interfaccia IDisposable. Quindi avvolgili sempre in un blocco using — così sei sicuro che Dispose() venga chiamato automaticamente anche se succede un errore. Questo ti protegge da memory leak e chiude il file correttamente.
Tra l'altro, di default sia BinaryWriter che BinaryReader chiamano anche Dispose() sullo stream di base che gli passi (tipo FileStream), quindi anche quello viene chiuso in automatico.
using FileStream fs = new FileStream("data.bin", FileMode.OpenOrCreate);
using BinaryWriter writer = new BinaryWriter(fs);
// ... lavoro
Codifica per le stringhe:
Per lavorare bene con le stringhe passate a BinaryWriter.Write(string) e lette con BinaryReader.ReadString(), specifica sempre la stessa codifica nei loro costruttori (tipo Encoding.UTF8). Se no rischi problemi con i caratteri non-ASCII.
Gestione delle eccezioni:
Le operazioni di I/O file possono sempre essere interrotte da fattori esterni (file mancante, permessi negati, disco pieno). Avvolgi sempre il codice con FileStream e BinaryReader/BinaryWriter in blocchi try-catch per essere più robusto.
BaseStream e posizione:
Puoi accedere allo stream di base tramite la proprietà BaseStream (tipo reader.BaseStream o writer.BaseStream). Utile se vuoi sapere la posizione attuale (BaseStream.Position) o spostarti nel file (BaseStream.Seek()).
// Esempio di uso di BaseStream.Position
using FileStream fs = new FileStream("data.bin", FileMode.OpenOrCreate);
using BinaryWriter writer = new BinaryWriter(fs);
writer.Write(123);
Console.WriteLine($"Posizione attuale nello stream: {writer.BaseStream.Position}"); // Mostra 4 (dimensione int)
writer.Write("Hello");
Console.WriteLine($"Posizione attuale nello stream: {writer.BaseStream.Position}"); // Mostra 4 + (1+5) = 10
⚠️ Il metodo Write(string) prima scrive la lunghezza della stringa come intero a 7 bit, poi i byte della stringa. Quindi la dimensione finale non è sempre 1 + lunghezza della stringa.
GO TO FULL VERSION