1. Classe FileStream: lavorare a pezzi
FileStream lo puoi immaginare come un tubo dell'acqua collegato direttamente al tuo file sul disco. Attraverso questo tubo puoi far passare i dati in modo controllato: mandare byte nel file (scrittura) o ricevere byte dal file (lettura). Diversamente dai metodi più "alto livello", che semplicemente "ti danno un bicchiere d'acqua", FileStream ti dà accesso diretto al "rubinetto", permettendoti di regolare il flusso d'acqua (byte) come ti serve.
FileStream lavora a livello di byte. Questo significa che non gli importa se è testo o immagine; per lui tutto è solo una sequenza di byte. Se lavori con file di testo tramite FileStream, dovrai convertire tu stesso le stringhe in byte (usando una codifica, tipo UTF-8) quando scrivi, e fare il contrario quando leggi.
Quando serve proprio FileStream?
- Lavorare con file molto grandi: Quando il file è così enorme che non puoi (o non ha senso) caricarlo tutto in RAM (tipo log da gigabyte, file video). FileStream ti permette di leggere o scrivere i dati a pezzi (chunk), usando la memoria in modo più furbo.
- Dati binari: Se lavori con file che non sono solo testo (immagini, audio, video, oggetti serializzati, file di database), FileStream è lo strumento base, perché ti dà accesso diretto ai byte.
- Controllo dettagliato sulle modalità di accesso: Devi aprire un file sia in lettura *che* in scrittura? O vuoi aprirlo in modo che altri programmi non possano toccarlo? O magari vuoi che più processi possano leggere lo stesso file insieme? FileStream ti dà il pieno controllo su queste modalità.
- Operazioni asincrone: Nelle app moderne ad alte prestazioni (tipo web server) è fondamentale che le operazioni sui file non blocchino il thread principale. FileStream supporta metodi asincroni (ReadAsync, WriteAsync), così il programma resta reattivo.
- Lettura/scrittura parziale o accesso casuale: Se ti serve leggere dati da un punto preciso del file (tipo dal 500-esimo byte) o scrivere nel mezzo del file, FileStream ti fa gestire la posizione del puntatore del file.
Errore tipico dei principianti: Usare FileStream per le cose più semplici, tipo scrivere una riga di testo in un file piccolo. In questi casi è troppo. FileStream è uno strumento per scenari specifici e più complessi.
2. Creare e aprire FileStream
Per iniziare a lavorare con un file tramite FileStream, devi crearne un'istanza. Si fa col costruttore, che prende diversi parametri importanti che decidono come vuoi interagire col file.
using System;
using System.IO; // Necessario per lavorare con FileStream
using System.Text; // Per lavorare con le codifiche (conversione stringhe-byte e viceversa)
Esempio base di lettura di un file di testo con FileStream:
Prima creiamo un file, così abbiamo qualcosa da leggere.
// Creiamo un semplice file di testo per la demo
string path = "example_filestream.txt";
// Apriamo lo stream per la lettura.
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
// Creiamo un buffer (array di byte) per tenere temporaneamente i dati letti.
byte[] buffer = new byte[fs.Length];
// Leggiamo i byte dallo stream nel buffer.
int bytesRead = fs.Read(buffer, 0, buffer.Length);
// Convertiamo i byte letti di nuovo in stringa, usando la codifica giusta (tipo UTF-8).
string content = Encoding.UTF8.GetString(buffer, 0, bytesRead);
Console.WriteLine("Letto dal file tramite FileStream: " + content);
fs.Close(); //chiudiamo lo stream
Parametri principali
- FileMode: come aprire il file (
Open,Create,AppendOpenOrCreateecc.) - FileAccess: cosa fare col file (
Read,Write,ReadWrite) - FileShare: se altri processi possono usare il file contemporaneamente (di solito per cose semplici non serve)
Errore tipico: Se ti dimentichi di chiudere FileStream, il file può "restare bloccato" — poi non riesci più a cancellarlo o riaprirlo!
3. Parametri del costruttore di FileStream
Il costruttore di FileStream ti permette di configurare esattamente come vuoi aprire il file. Ecco i parametri principali:
new FileStream(
string path, // Percorso del file (assoluto o relativo)
FileMode mode, // Come aprire il file (crea, apri, sovrascrivi ecc.)
FileAccess access, // Che accesso vuoi (solo lettura, solo scrittura, lettura+scrittura)
FileShare share // Come altri processi possono accedere al file mentre è aperto (opzionale)
);
Vediamo i valori degli enum FileMode e FileAccess:
FileMode (Modalità di apertura file):
Decide come il sistema operativo deve trattare il file quando lo apri.
FileMode.Open: Apre un file esistente. Se il file al percorso indicato non c'è, lancia FileNotFoundException.FileMode.Create: Crea un nuovo file. Se esiste già un file con quel nome, verrà completamente sovrascritto (il contenuto sparisce).
FileAccess (Permessi di accesso al file):
Decide che operazioni può fare il tuo programma sul file aperto.
FileAccess.Read: Il file è aperto solo per lettura. Non puoi scriverci sopra.FileAccess.Write: Il file è aperto solo per scrittura. Non puoi leggerlo.FileAccess.ReadWrite: Il file è aperto sia per lettura che scrittura. È la modalità più flessibile, ma anche più "delicata", perché devi gestire la posizione nello stream.
FileShare (Condivisione file):
Decide come altri processi possono aprire lo stesso file mentre è aperto dal tuo programma. Molto importante per evitare blocchi.
FileShare.Read: Altri processi possono leggere il file mentre è aperto dal tuo FileStream, ma non possono scriverci.FileShare.Write: Altri processi possono scrivere nel file mentre è aperto dal tuo FileStream, ma non possono leggerlo.FileShare.ReadWrite: Altri processi possono leggere e scrivere nel file. È la modalità più "libera", ma può creare conflitti se più programmi modificano il file insieme.
Più dettagli sulle modalità nella prossima lezione.
4. Lettura e scrittura dati con FileStream
Quando lavori con FileStream, maneggi byte. Questo significa che per i dati di testo devi convertire tra stringhe e array di byte, usando le classi di codifica (tipo System.Text.Encoding.UTF8).
Scrivere dati in un file con FileStream
Quando scrivi, converti i tuoi dati (tipo una stringa) in un array di byte, e poi scrivi questi byte nello stream.
string outputPath = "user_data.txt";
string userName = "Ivan Petrov";
// Convertiamo la stringa in array di byte, usando la codifica UTF-8
byte[] userNameBytes = Encoding.UTF8.GetBytes(userName);
// Apriamo FileStream per la scrittura.
FileStream fsWrite = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
// Scriviamo l'array di byte nello stream.
fsWrite.Write(userNameBytes, 0, userNameBytes.Length);
Console.WriteLine($"Nome '{userName}' scritto con successo nel file '{outputPath}'.");
fsWrite.Close(); //chiudiamo lo stream
Leggere dati da un file con FileStream
Quando leggi, prendi i byte dallo stream in un buffer, poi li converti nel formato che ti serve (tipo una stringa).
string inputPath = "user_data.txt";
// Apriamo FileStream per la lettura
FileStream fsRead = new FileStream(inputPath, FileMode.Open, FileAccess.Read);
// Creiamo un buffer grande quanto il file per leggere tutti i byte.
byte[] buffer = new byte[fsRead.Length];
// Leggiamo i byte dallo stream nel buffer.
int bytesRead = fsRead.Read(buffer, 0, buffer.Length);
// Convertiamo i byte letti in stringa.
string loadedUserName = Encoding.UTF8.GetString(buffer, 0, bytesRead);
Console.WriteLine($"Nome dal file (tramite FileStream): {loadedUserName}");
fsRead.Close(); //chiudiamo lo stream
5. Lavorare con file grandi
Il vantaggio principale di FileStream rispetto ai metodi File.ReadAll... è che puoi leggere e scrivere il file a pezzi, cosa fondamentale se lavori con file grandi che non stanno tutti in RAM.
Lettura di file grandi a pezzi
Quando leggi un file a pezzi, usi un buffer (array di byte) di dimensione fissa e ci leggi dentro finché non arrivi alla fine del file.
string bigFilePath = "bigfile.bin"; //file grande
int bufferSize = 4096; // Dimensione buffer, tipo 4 KB
byte[] buffer = new byte[bufferSize]; // Creiamo il buffer
int bytesRead; // Quanti byte sono stati letti davvero
long totalBytesRead = 0; // Totale byte letti
// apriamo lo stream
FileStream fs = new FileStream(bigFilePath, FileMode.Open, FileAccess.Read);
int chunkNumber = 1;
// Il ciclo continua finché fs.Read() restituisce un numero positivo di byte
while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
{
totalBytesRead += bytesRead;
Console.WriteLine($"Parte {chunkNumber++}: letti {bytesRead} byte. Totale: {totalBytesRead} byte.");
// !!! Qui puoi processare i "pezzi" di dati letti !!!
}
fs.Close(); //chiudiamo lo stream
Nota importante: Il metodo fs.Read(buffer, offset, count) non garantisce che riempia tutto il buffer. Restituisce il numero di byte effettivamente letti, che può essere meno di count (soprattutto alla fine del file). Usa sempre il valore restituito bytesRead per gestire bene i dati.
Scrivere grandi quantità di dati a pezzi
Come per la lettura, puoi scrivere grandi quantità di dati in un file a pezzi.
string bigOutputPath = "big_output.txt";
string longText = new string('A', 1_000_000); // Stringa di un milione di 'A'
byte[] longTextBytes = Encoding.UTF8.GetBytes(longText);
int writeBufferSize = 1024; // Scriviamo 1 KB alla volta
// FileMode.Create: creiamo il file
FileStream fsWrite = new FileStream(bigOutputPath, FileMode.Create, FileAccess.Write);
for (int i = 0; i < longTextBytes.Length; i += writeBufferSize)
{
// Calcoliamo quanti byte restano da scrivere in questa iterazione
int bytesToWrite = Math.Min(writeBufferSize, longTextBytes.Length - i);
// Scriviamo una porzione di dati da longTextBytes, partendo dall'offset 'i'
fsWrite.Write(longTextBytes, i, bytesToWrite);
Console.WriteLine($"Scritti {bytesToWrite} byte");
}
fsWrite.Close(); //chiudiamo lo stream
6. Trappole nascoste ed errori tipici
Anche con uno strumento potente come FileStream, ci sono delle cose a cui stare attenti:
Bufferizzazione e Flush(): Come già detto, i dati possono restare nel buffer in memoria senza arrivare subito sul disco. Se non usi using e non chiami Close()/Dispose(), ma chiudi solo il programma, i dati possono andare persi. Chiama sempre Flush() (o affidati a using/Close()) per essere sicuro che i dati siano scritti.
Gestione delle eccezioni: Gli errori di I/O (tipo IOException se provi a scrivere su un disco pieno, UnauthorizedAccessException per mancanza di permessi, FileNotFoundException se provi ad aprire un file che non esiste in modalità Open) sono normali. Metti sempre le operazioni con FileStream dentro blocchi try-catch.
Codifiche: Quando lavori con dati di testo tramite FileStream (che lavora coi byte), sei tu responsabile di scegliere la codifica giusta (Encoding.UTF8, Encoding.ASCII, Encoding.Unicode ecc.) quando converti stringhe in byte e viceversa. Se sbagli codifica, ottieni "caratteri strani".
Gestione della posizione: Se usi Seek(), fai attenzione ai parametri offset e origin, per non finire fuori dal file o in un punto sbagliato.
Blocchi sui file (FileShare): Se apri un file con FileShare.None, altri processi non potranno accedervi. Può essere un problema se un altro programma (o anche un altro thread nel tuo programma) prova a usare lo stesso file. Scegli sempre la modalità FileShare più adatta.
GO TO FULL VERSION