CodeGym /Corsi /C# SELF /Classi di istanza FileInfo e DirectoryInfo

Classi di istanza FileInfo e DirectoryInfo

C# SELF
Livello 39, Lezione 1
Disponibile

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
Name
Nome del file
fileInfo.Name
FullName
Percorso completo
fileInfo.FullName
Length
Dimensione del file in byte
fileInfo.Length
Directory
Directory genitore (DirectoryInfo)
fileInfo.Directory.FullName
Exists
Il file esiste realmente?
fileInfo.Exists
Extension
Estensione del file (.txt)
fileInfo.Extension
CreationTime
Data di creazione
fileInfo.CreationTime
LastWriteTime
Data dell'ultima modifica
fileInfo.LastWriteTime
IsReadOnly
Sola lettura?
fileInfo.IsReadOnly
Metodi
CopyTo()
Copiare il file
fileInfo.CopyTo("copy.txt")
Delete()
Cancellare il file
fileInfo.Delete()
MoveTo()
Spostare il file
fileInfo.MoveTo("move.txt")
OpenRead()
Aprire uno stream in lettura
using var stream = fileInfo.OpenRead()
OpenWrite()
Aprire uno stream in scrittura
using var stream = fileInfo.OpenWrite()

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
Name
Nome della cartella
dirInfo.Name
FullName
Percorso completo
dirInfo.FullName
Parent
Cartella genitore (DirectoryInfo)
dirInfo.Parent.FullName
Exists
La cartella esiste?
dirInfo.Exists
CreationTime
Data di creazione
dirInfo.CreationTime
LastWriteTime
Data di modifica
dirInfo.LastWriteTime
Metodi
Create()
Creare la cartella
dirInfo.Create()
Delete()
Cancellare la cartella
dirInfo.Delete()
GetFiles()
Array di file (array di FileInfo)
dirInfo.GetFiles()
GetDirectories()
Array di sottocartelle (array di DirectoryInfo)
dirInfo.GetDirectories()
EnumerateFiles()
Enumerazione dei file (restituisce IEnumerable<FileInfo>, modalità lazy)
dirInfo.EnumerateFiles()
MoveTo()
Spostare la cartella
dirInfo.MoveTo("path")

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
File.Delete(path)
new FileInfo(path).Delete()
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.

2
Compito
C# SELF, livello 39, lezione 1
Bloccato
Visualizzazione dell'elenco dei file in una directory
Visualizzazione dell'elenco dei file in una directory
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION