1. Introduzione
In .NET per lavorare con file e cartelle esistono due gruppi di classi filosoficamente diversi:
Classi statiche: File, Directory — funzionano come un insieme di funzioni utilitarie: chiami il metodo, passi il percorso, ottieni il risultato.
Classi istanziate: FileInfo, DirectoryInfo — rappresentano file e cartelle specifici come oggetti con proprietà e metodi propri.
Perché entrambi gli approcci? È un compromesso tra semplicità d'uso (metodi statici) e flessibilità orientata agli oggetti (classi istanziate). Ognuno è comodo in scenari diversi.
2. Filosofia delle classi statiche
Le classi File e Directory seguono il principio "Fai semplice!". Forniscono un'interfaccia diretta per eseguire operazioni sul file system senza dover creare oggetti intermedi.
// Verificare l'esistenza del file
if (File.Exists("document.txt"))
{
// Leggere tutto il testo
string content = File.ReadAllText("document.txt");
// Creare un backup
File.Copy("document.txt", "document_backup.txt");
// Eliminare l'originale
File.Delete("document.txt");
}
È comodo per operazioni semplici e una tantum: non devi pensare agli oggetti, al loro ciclo di vita o stato — chiami semplicemente il metodo col percorso del file.
Analogamente funziona Directory:
// Creare una cartella
Directory.CreateDirectory(@"C:\MyProject\Data");
// Ottenere tutti i file di testo
string[] textFiles = Directory.GetFiles(@"C:\MyProject", "*.txt");
// Verificare l'esistenza della cartella
if (Directory.Exists(@"C:\Temp"))
{
Directory.Delete(@"C:\Temp", recursive: true);
}
3. Confronto degli approcci con esempi pratici
Esempio 1: Copia semplice di un file
Approccio statico:
string sourcePath = "original.txt";
string destinationPath = "copy.txt";
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destinationPath, overwrite: true);
Console.WriteLine("File copiato");
}
else
{
Console.WriteLine("File sorgente non trovato");
}
Approccio istanziato:
var sourceFile = new FileInfo("original.txt");
var destinationFile = new FileInfo("copy.txt");
if (sourceFile.Exists)
{
sourceFile.CopyTo(destinationFile.FullName, overwrite: true);
Console.WriteLine("File copiato");
}
else
{
Console.WriteLine("File sorgente non trovato");
}
Qui l'approccio statico è più conciso. Ma cosa succede se serve informazione aggiuntiva?
Esempio 2: Copia con controllo della dimensione
Approccio statico:
string sourcePath = "largefile.zip";
string destinationPath = "backup.zip";
if (File.Exists(sourcePath))
{
var fileInfo = new FileInfo(sourcePath); // Alla fine hai comunque creato un oggetto!
if (fileInfo.Length > 100 * 1024 * 1024) // Più di 100 MB
{
Console.WriteLine($"Attenzione: si sta copiando un file grande ({fileInfo.Length / 1024 / 1024} MB)");
}
File.Copy(sourcePath, destinationPath, overwrite: true);
}
Approccio istanziato:
var sourceFile = new FileInfo("largefile.zip");
if (sourceFile.Exists)
{
if (sourceFile.Length > 100 * 1024 * 1024) // Più di 100 MB
{
Console.WriteLine($"Attenzione: si sta copiando un file grande ({sourceFile.Length / 1024 / 1024} MB)");
}
sourceFile.CopyTo("backup.zip", overwrite: true);
}
Qui l'approccio orientato agli oggetti è più naturale: lavori col file come oggetto e usi le sue proprietà.
Esempio 3: Analisi del contenuto di una cartella
Approccio statico:
string folderPath = @"C:\Documents";
if (Directory.Exists(folderPath))
{
string[] files = Directory.GetFiles(folderPath);
string[] subdirs = Directory.GetDirectories(folderPath);
Console.WriteLine($"File: {files.Length}, Cartelle: {subdirs.Length}");
// Per ottenere le dimensioni servono comunque oggetti FileInfo
long totalSize = 0;
foreach (string filePath in files)
{
var fileInfo = new FileInfo(filePath);
totalSize += fileInfo.Length;
}
Console.WriteLine($"Dimensione totale: {totalSize / 1024} KB");
}
Approccio istanziato:
var folder = new DirectoryInfo(@"C:\Documents");
if (folder.Exists)
{
var files = folder.GetFiles();
var subdirs = folder.GetDirectories();
Console.WriteLine($"File: {files.Length}, Cartelle: {subdirs.Length}");
long totalSize = files.Sum(f => f.Length); // Le informazioni sono già disponibili!
Console.WriteLine($"Dimensione totale: {totalSize / 1024} KB");
}
Qui DirectoryInfo vince: le collezioni FileInfo[] contengono già i metadata.
4. Criteri per scegliere l'approccio
Usa le classi statiche (File/Directory) quando:
- L'operazione è semplice e una tantum. Devi rapidamente verificare l'esistenza di un file, eliminarlo o leggerne il contenuto — i metodi statici sono ideali.
// Lettura semplice della configurazione
if (File.Exists("config.json"))
{
string config = File.ReadAllText("config.json");
// elaborazione della configurazione...
}
- Non ti servono informazioni sulle proprietà del file. Se dimensione, date o attributi non sono importanti — le chiamate statiche sono più corte e più adatte.
- Lavori con percorsi, non con file come oggetti. Quando la logica opera su stringhe di percorso, i metodi statici risultano più naturali.
Usa le classi istanziate (FileInfo/DirectoryInfo) quando:
- Ti serve molta informazione su un singolo file/cartella. Proprietà come Length, CreationTime, Attributes sono disponibili direttamente.
var logFile = new FileInfo("application.log");
Console.WriteLine($"Dimensione log: {logFile.Length / 1024} KB");
Console.WriteLine($"Ultima modifica: {logFile.LastWriteTime}");
Console.WriteLine($"Posizione: {logFile.Directory.FullName}");
- Esegui molte operazioni su uno stesso file. Crei l'oggetto una volta e lo usi per azioni diverse.
var document = new FileInfo("report.docx");
if (document.Exists)
{
var backup = document.CopyTo($"report_backup_{DateTime.Now:yyyyMMdd}.docx");
document.MoveTo("archive/report.docx");
Console.WriteLine($"Documento archiviato, creata copia {backup.Name}");
}
- Lavori con collezioni di file. GetFiles() e GetDirectories() restituiscono oggetti completi di informazioni.
- Ti serve un'architettura orientata agli oggetti. File/cartelle come oggetti sono più facili da passare, memorizzare e usare in LINQ.
5. Performance e caching
Caching nelle classi istanziate
Una caratteristica chiave di FileInfo/DirectoryInfo è il caching dei metadata. Al primo accesso a una proprietà (per esempio Length o CreationTime) .NET fa una chiamata di sistema, carica tutte le informazioni e le memorizza nella cache dentro l'oggetto.
var file = new FileInfo("document.txt");
// Primo accesso - chiamata di sistema per caricare tutti i metadata
long size = file.Length;
// Accessi successivi usano la cache - molto veloci
DateTime created = file.CreationTime;
DateTime modified = file.LastWriteTime;
bool readOnly = file.IsReadOnly;
Se ti servono più proprietà di uno stesso file, l'approccio orientato agli oggetti è più efficiente: una chiamata di sistema invece di molte.
Problema della cache obsoleta
Il rovescio della medaglia è che le informazioni possono diventare obsolete se il file cambia fuori dal tuo programma. Usa Refresh():
var file = new FileInfo("data.txt");
Console.WriteLine($"Dimensione: {file.Length}"); // Per esempio 1000 byte
// Nel frattempo un altro programma modifica il file...
Console.WriteLine($"Dimensione: {file.Length}"); // Ancora 1000 byte dalla cache!
// Forzare l'aggiornamento
file.Refresh();
Console.WriteLine($"Dimensione: {file.Length}"); // Ora la dimensione aggiornata
Le chiamate statiche vanno sempre direttamente al file system, quindi non hanno questo problema.
Operazioni di massa
Su grandi insiemi di file la scelta dell'API influisce sulle performance:
// Approccio statico — molte chiamate di sistema
string[] files = Directory.GetFiles(@"C:\Photos");
foreach (string filePath in files)
{
var info = new FileInfo(filePath); // Chiamata di sistema per ogni file
if (info.Length > 10 * 1024 * 1024) // Più di 10 MB
{
Console.WriteLine($"Foto grande: {info.Name}");
}
}
// Approccio istanziato — una chiamata di sistema per la cartella
var photosDir = new DirectoryInfo(@"C:\Photos");
foreach (var file in photosDir.GetFiles()) // Le informazioni vengono caricate subito
{
if (file.Length > 10 * 1024 * 1024)
{
Console.WriteLine($"Foto grande: {file.Name}");
}
}
6. Differenze nelle API e funzionalità
Funzionalità uniche delle classi istanziate
var file = new FileInfo(@"C:\Projects\MyApp\source\Program.cs");
// Navigazione nella gerarchia delle cartelle
DirectoryInfo projectDir = file.Directory.Parent; // MyApp
DirectoryInfo sourceDir = file.Directory; // source
// Informazioni dettagliate sul file
Console.WriteLine($"Estensione: {file.Extension}");
Console.WriteLine($"Sola lettura: {file.IsReadOnly}");
Console.WriteLine($"Attributi: {file.Attributes}");
// Lavorare con la directory come oggetto
var dir = new DirectoryInfo(@"C:\Projects");
DirectoryInfo parent = dir.Parent; // C:\
DirectoryInfo root = dir.Root; // C:\
Funzionalità uniche delle classi statiche
// Lettura e scrittura di testo in una riga
string content = File.ReadAllText("config.txt");
File.WriteAllText("output.txt", "Hello World");
// Lavorare con le stringhe
string[] lines = File.ReadAllLines("data.txt");
File.WriteAllLines("output.txt", new[] { "Line 1", "Line 2" });
// Aggiungere testo al file
File.AppendAllText("log.txt", $"{DateTime.Now}: Application started\n");
// Lavorare con i byte
byte[] data = File.ReadAllBytes("image.jpg");
File.WriteAllBytes("copy.jpg", data);
7. Raccomandazioni pratiche
Scenario 1: Utility di backup
Per copiare controllando dimensioni e date è più comodo usare le classi istanziate:
public void BackupDirectory(string sourcePath, string backupPath)
{
var sourceDir = new DirectoryInfo(sourcePath);
var backupDir = new DirectoryInfo(backupPath);
if (!backupDir.Exists)
backupDir.Create();
foreach (var file in sourceDir.GetFiles())
{
var backupFile = new FileInfo(Path.Combine(backupPath, file.Name));
// Copiamo solo se il file è più recente o non esiste
if (!backupFile.Exists || file.LastWriteTime > backupFile.LastWriteTime)
{
file.CopyTo(backupFile.FullName, overwrite: true);
Console.WriteLine($"Copiato: {file.Name} ({file.Length / 1024} KB)");
}
}
}
Scenario 2: Lavoro semplice con file di testo
Per caricare/salvare dati semplici bastano i metodi statici:
public void SaveUserPreferences(string username, string theme, bool notifications)
{
string configPath = "user.config";
string[] settings = {
$"Username={username}",
$"Theme={theme}",
$"Notifications={notifications}"
};
File.WriteAllLines(configPath, settings);
}
public Dictionary<string, string> LoadUserPreferences()
{
string configPath = "user.config";
var preferences = new Dictionary<string, string>();
if (!File.Exists(configPath))
{
// Creiamo le impostazioni di default
SaveUserPreferences("User", "Light", true);
return LoadUserPreferences();
}
string[] lines = File.ReadAllLines(configPath);
foreach (string line in lines)
{
if (line.Contains('='))
{
string[] parts = line.Split('=', 2);
preferences[parts[0]] = parts[1];
}
}
return preferences;
}
Scenario 3: Analisi del file system
Per report sull'utilizzo del disco le classi istanziate sono perfette:
public void AnalyzeDiskUsage(string path)
{
var directory = new DirectoryInfo(path);
var report = new Dictionary<string, long>();
foreach (var file in directory.GetFiles("*", SearchOption.AllDirectories))
{
string extension = file.Extension.ToLower();
if (string.IsNullOrEmpty(extension))
extension = "(senza estensione)";
if (!report.ContainsKey(extension))
report[extension] = 0;
report[extension] += file.Length;
}
var sortedReport = report.OrderByDescending(kvp => kvp.Value);
foreach (var item in sortedReport.Take(10))
{
Console.WriteLine($"{item.Key}: {item.Value / 1024 / 1024} MB");
}
}
8. Errori tipici e insidie
Errore: Mescolare approcci senza bisogno
A volte si inizia con metodi statici e poi si creano oggetti per metadata — si ottiene duplicazione inutile delle chiamate:
// Inefficiente - due accessi al file system
if (File.Exists("document.txt"))
{
var fileInfo = new FileInfo("document.txt"); // Duplicazione della verifica di esistenza
Console.WriteLine($"Dimensione: {fileInfo.Length}");
}
// Meglio usare subito l'approccio oggettuale
var fileInfo = new FileInfo("document.txt");
if (fileInfo.Exists)
{
Console.WriteLine($"Dimensione: {fileInfo.Length}");
}
Errore: Ignorare la cache obsoleta
Quando lavori a lungo con file che possono cambiare esternamente, aggiorna la cache con Refresh():
var logFile = new FileInfo("application.log");
while (true)
{
logFile.Refresh(); // Aggiorniamo le informazioni sul file
if (logFile.Length > 100 * 1024 * 1024) // 100 MB
{
// Archiviamo il log
logFile.MoveTo($"logs/archived_{DateTime.Now:yyyyMMdd_HHmmss}.log");
break;
}
Thread.Sleep(60000); // Controlliamo ogni minuto
}
Errore: Scelta sbagliata per operazioni di massa
Quando processi migliaia di file la scelta dell'API è critica per le performance:
// Lento - molte piccole chiamate al file system
string[] allFiles = Directory.GetFiles(@"C:\BigFolder", "*", SearchOption.AllDirectories);
var largeFiles = allFiles.Where(path => new FileInfo(path).Length > 1024 * 1024).ToList();
// Più veloce - usiamo informazioni già pronte
var folder = new DirectoryInfo(@"C:\BigFolder");
var largeFiles = folder.GetFiles("*", SearchOption.AllDirectories)
.Where(file => file.Length > 1024 * 1024)
.ToList();
GO TO FULL VERSION