1. Introduzione
Se le classi statiche come File e Directory sono come un coltellino svizzero universale: sempre a portata di mano, risolvono rapidamente un compito senza legarsi a un oggetto specifico, allora FileInfo e DirectoryInfo sono uno strumento personalizzato: vengono creati per un file o una cartella specifica, "conoscono" molte cose su di essi e permettono di lavorare in modo più comodo e flessibile, specialmente quando si fanno molte operazioni sullo stesso oggetto.
Le classi di istanza conservano i dettagli su un oggetto specifico del file system, e dopo il primo caricamento delle proprietà non è necessario interrogare di nuovo il file system per ottenere le stesse informazioni (a meno che l'oggetto non sia diventato obsoleto).
- FileInfo — per lavorare con un file specifico.
- DirectoryInfo — per lavorare con una directory (cartella) specifica.
Contengono proprietà e metodi che permettono di ottenere informazioni dettagliate (dimensione, data di creazione, estensione, attributi disponibili) ed eseguire azioni sul file/cartella: copiare, cancellare, spostare ecc.
Com'è fatta la struttura di FileInfo e DirectoryInfo
Entrambe le classi ereditano da una classe astratta comune FileSystemInfo, il che permette di scrivere codice che lavora con file e cartelle in modo generico.
System.Object
|
System.MarshalByRefObject
|
System.IO.FileSystemInfo (classe astratta)
| |
FileInfo DirectoryInfo
Quando usare le classi di istanza?
- Se ti serve molta informazione su un singolo file/cartella (dimensione, data di modifica, estensione, attributi ecc.) e questi dati vengono riutilizzati più volte.
- Se vuoi scorrere tutti i file/cartelle in una directory e lavorare con ogni oggetto come un'istanza "viva".
- Per ottimizzazione, quando è importante non andare troppo spesso sul file system (caching delle informazioni).
- Per codice più orientato agli oggetti (backup, libreria multimediale, file manager ecc.).
Come creare un'istanza di FileInfo o DirectoryInfo
using System.IO;
// Creazione di un oggetto FileInfo per un file esistente (o non esistente!):
var fileInfo = new FileInfo("notes.txt");
// Creazione di un oggetto DirectoryInfo per una cartella:
var dirInfo = new DirectoryInfo(@"C:\Projects");
// Si possono usare percorsi relativi o assoluti!
Nota importante: creare un oggetto FileInfo o DirectoryInfo NON crea il file/la cartella nel file system! È solo una descrizione (un riferimento).
2. Lavorare con FileInfo
Vediamo le proprietà e i metodi principali di questa classe. Ecco una guida rapida:
| Proprietà/metodo | Cosa restituisce? | Esempio d'uso |
|---|---|---|
|
Nome del file | |
|
Percorso completo | |
|
Dimensione del file in byte | |
|
Directory genitore (DirectoryInfo) | |
|
Il file esiste realmente? | |
|
Estensione del file (.txt) | |
|
Data di creazione | |
|
Data dell'ultima modifica | |
|
Sola lettura? | |
| Metodi | ||
|
Copiare il file | |
|
Cancellare il file | |
|
Spostare il file | |
|
Aprire uno stream in lettura | |
|
Aprire uno stream in scrittura | |
Esempio: Informazioni su un file
Aggiungiamo un piccolo modulo che ottiene informazioni dettagliate su un file usando FileInfo.
Console.WriteLine("Inserisci il nome del file:");
string fileName = Console.ReadLine();
var file = new FileInfo(fileName);
if (file.Exists)
{
Console.WriteLine($"Nome file: {file.Name}");
Console.WriteLine($"Percorso: {file.FullName}");
Console.WriteLine($"Dimensione: {file.Length} byte");
Console.WriteLine($"Estensione: {file.Extension}");
Console.WriteLine($"Data di creazione: {file.CreationTime}");
Console.WriteLine($"Ultima modifica: {file.LastWriteTime}");
// In più: mostrare la directory genitore
Console.WriteLine($"Cartella genitore: {file.DirectoryName}");
}
else
{
Console.WriteLine("File non trovato.");
}
Nota: non leggiamo il contenuto del file, otteniamo solo la meta-informazione.
Pratica: Copiare e cancellare un file
// ... All'interno del metodo principale dopo aver mostrato le info del file:
Console.WriteLine("Inserisci il percorso per la copia del file:");
string copyPath = Console.ReadLine();
try
{
file.CopyTo(copyPath);
Console.WriteLine($"File copiato con successo in {copyPath}");
}
catch (IOException ex)
{
Console.WriteLine($"Impossibile copiare il file: {ex.Message}");
}
// Ora cancelliamo la copia
Console.WriteLine("Cancellare la copia del file? (y/n):");
if (Console.ReadLine().Trim().ToLower() == "y")
{
var copyFile = new FileInfo(copyPath);
if (copyFile.Exists)
{
copyFile.Delete();
Console.WriteLine("Copia cancellata.");
}
}
3. Lavorare con DirectoryInfo
Vediamo cosa offre DirectoryInfo:
| Proprietà/metodo | Cosa restituisce? | Esempio d'uso |
|---|---|---|
|
Nome della cartella | |
|
Percorso completo | |
|
Cartella genitore (DirectoryInfo) | |
|
La cartella esiste? | |
|
Data di creazione | |
|
Data di modifica | |
| Metodi | ||
|
Creare la cartella | |
|
Cancellare la cartella | |
|
Array di file (array di FileInfo) | |
|
Array di sottocartelle (array di DirectoryInfo) | |
|
Enumerazione dei file (restituisce IEnumerable<FileInfo>, modalità lazy) | |
|
Spostare la cartella | |
Esempio: Scorrere file e cartelle
Console.WriteLine("Inserisci il percorso della cartella:");
string path = Console.ReadLine();
var dir = new DirectoryInfo(path);
if (!dir.Exists)
{
Console.WriteLine("Cartella non trovata!");
return;
}
Console.WriteLine("\n--- File ---");
foreach (var file in dir.GetFiles())
{
Console.WriteLine($"{file.Name} ({file.Length} byte)");
}
Console.WriteLine("\n--- Sottocartelle ---");
foreach (var subDir in dir.GetDirectories())
{
Console.WriteLine(subDir.Name);
}
4. Dettagli utili
Metodi statici vs classi di istanza
Quando usare quale approccio? Se fai un'operazione veloce e "una tantum" — per esempio File.Exists(path) o File.ReadAllText(path) — i metodi statici sono più adatti. Sono più semplici e leggermente più veloci grazie a sovraccarichi minimi.
Se invece vuoi ottenere molte informazioni su un file o una cartella, eseguire operazioni ripetute su quell'oggetto, o semplicemente scrivere in stile OOP, è meglio usare le istanze FileInfo e DirectoryInfo.
Interessante notare che sotto il cofano entrambi gli approcci usano chiamate di sistema simili a basso livello. Ma le classi di istanza mettono in cache alcune proprietà (dimensione, date, attributi), riducendo il numero di accessi al file system — molto comodo quando si scorre un grande numero di file.
Un po' su data e ora
Le proprietà CreationTime, LastWriteTime, LastAccessTime restituiscono valori di tipo DateTime.
Console.WriteLine($"File creato: {file.CreationTime:yyyy-MM-dd HH:mm:ss}");
Console.WriteLine($"Ultima modifica: {file.LastWriteTime:yyyy-MM-dd HH:mm:ss}");
Se il file o la cartella è stato modificato sul disco dopo che hai ottenuto l'istanza FileInfo o DirectoryInfo, le informazioni in cache possono diventare obsolete. Per aggiornarle, chiama file.Refresh().
Consigli pratici
- Le classi di istanza sono comode quando costruisci un wrapper attorno al file system: backup, libreria multimediale, indicizzazione.
- Funzionano molto bene con LINQ: puoi filtrare per dimensione, data o estensione ed eseguire operazioni sugli oggetti selezionati.
- Per operazioni massive è preferibile usare EnumerateFiles() e EnumerateDirectories() piuttosto che GetFiles()/GetDirectories() — l'enumerazione lazy risparmia memoria e accelera l'inizio dell'elaborazione.
Confronto tra approccio statico e di istanza
| Metodi statici | Classi di istanza | |
|---|---|---|
| Sintassi | |
|
| Caching | No | Sì |
| Molte informazioni | Devi chiamare molti metodi | Sono presenti nell'oggetto |
| Stile OOP | No | Sì |
| Operazioni massive | Scomodo | Comodo |
| Lavoro con stream | Sì | Sì |
Aggiornare informazioni e oggetti
Gli oggetti FileInfo/DirectoryInfo mettono in cache i valori dopo il primo accesso alle proprietà. Se l'oggetto (file o cartella) è stato modificato sul disco dopo la creazione dell'istanza, per aggiornare le informazioni chiamare il metodo .Refresh().
var file = new FileInfo("notes.txt");
long oldSize = file.Length;
// Nel frattempo qualcuno (o tu stesso) modifica il file fuori dal programma
file.Refresh();
long newSize = file.Length;
Non capita spesso, ma se il tuo programma osserva il file system, questo meccanismo è importante.
5. Errori tipici quando si lavora con classi di istanza
Fraintendimento: se si crea l'oggetto new FileInfo("file.txt"), non significa che il file esista già. In realtà non è così — il file appare solo dopo una scrittura esplicita o la chiamata a Create().
Tentare di ottenere proprietà di un file che non esiste: alcune proprietà restituiranno valori di default (ad esempio la dimensione 0), ma cercare di aprire uno stream in lettura solleverà un'eccezione.
Con le cartelle vale lo stesso: creare una DirectoryInfo non garantisce che la cartella esista sul disco fino alla chiamata a Create() o al suo effettivo arrivo.
GO TO FULL VERSION