1. Introduzione
Su Windows (e non solo) ogni file e directory ha un insieme di proprietà (metadati): percorso completo, nome, estensione, dimensione, date di creazione/modifica/accesso, attributi ecc. Immagina: un file non è solo byte, ma anche un vero e proprio profilo che puoi leggere con FileInfo e DirectoryInfo.
| Proprietà | Descrizione | Esempio |
|---|---|---|
| Percorso completo | Nome completo del file/cartella | |
| Nome | Nome senza percorso | |
| Estensione | .txt, .csv, .jpg ecc. | |
| Dimensione (Bytes) | Dimensione del file in byte | |
| Data di creazione | Quando è stato creato il file/cartella | |
| Data di modifica | Quando è stato modificato l'ultima volta il contenuto | |
| Attributi | Per esempio, sola lettura, nascosto ecc. | |
| Cartella padre | La cartella che contiene il file/directory | |
2. Lavorare in dettaglio con le proprietà dei file
Analisi dettagliata dei timestamp
Le proprietà CreationTime, LastWriteTime, LastAccessTime restituiscono DateTime e il loro comportamento dipende dal file system e dalle operazioni sul file.
var fileInfo = new FileInfo("document.txt");
if (fileInfo.Exists)
{
Console.WriteLine($"Creato: {fileInfo.CreationTime:yyyy-MM-dd HH:mm:ss}");
Console.WriteLine($"Modificato: {fileInfo.LastWriteTime:yyyy-MM-dd HH:mm:ss}");
Console.WriteLine($"Ultimo accesso: {fileInfo.LastAccessTime:yyyy-MM-dd HH:mm:ss}");
// Differenza tra creazione e ultima modifica
var age = fileInfo.LastWriteTime - fileInfo.CreationTime;
Console.WriteLine($"Il file è stato modificato per: {age.TotalDays:F1} giorni");
}
È interessante che durante la copia di un file la data di creazione generalmente viene aggiornata a quella corrente, ma la data di modifica può rimanere quella dell'originale. Questo è importante per backup e analisi delle attività.
Lavorare con estensioni e nomi di file
Le proprietà FullName, Name e Extension sembrano semplici, ma ci sono dettagli: assenza di estensione, estensioni composte come .tar.gz e file nascosti che iniziano con un punto.
var files = new[]
{
new FileInfo("document.txt"),
new FileInfo("archive.tar.gz"),
new FileInfo("README"),
new FileInfo(".gitignore")
};
foreach (var file in files)
{
Console.WriteLine($"Nome completo: {file.FullName}");
Console.WriteLine($"Nome: {file.Name}");
Console.WriteLine($"Estensione: '{file.Extension}'");
// Nome senza estensione
string nameWithoutExtension = Path.GetFileNameWithoutExtension(file.Name);
Console.WriteLine($"Nome senza estensione: {nameWithoutExtension}");
Console.WriteLine("---");
}
Dimensione dei file e formattazione
La proprietà Length restituisce la dimensione in byte; per l'utente è più comodo vedere KB/MB/GB. Funzione helper:
static string FormatFileSize(long bytes)
{
string[] suffixes = { "B", "KB", "MB", "GB", "TB" };
int counter = 0;
decimal number = bytes;
while (Math.Round(number / 1024) >= 1)
{
number /= 1024;
counter++;
}
return $"{number:N1} {suffixes[counter]}";
}
// Uso
var file = new FileInfo("bigfile.zip");
if (file.Exists)
{
Console.WriteLine($"Dimensione file: {FormatFileSize(file.Length)}");
}
3. Lavorare avanzato con gli attributi dei file
Gli attributi sono rappresentati dall'enum FileAttributes (set di flag bitwise), quindi un file può avere più attributi contemporaneamente. È comodo verificarli con HasFlag.
var fileInfo = new FileInfo("important.txt");
Console.WriteLine($"Attributi file: {fileInfo.Attributes}");
// Verifichiamo attributi specifici
if (fileInfo.Attributes.HasFlag(FileAttributes.Hidden))
{
Console.WriteLine("Il file è nascosto!");
}
if (fileInfo.Attributes.HasFlag(FileAttributes.ReadOnly))
{
Console.WriteLine("Il file è protetto in scrittura!");
}
if (fileInfo.Attributes.HasFlag(FileAttributes.System))
{
Console.WriteLine("Questo è un file di sistema!");
}
Gli attributi si possono modificare programmaticamente:
// Rendere il file nascosto
fileInfo.Attributes |= FileAttributes.Hidden;
// Rimuovere l'attributo "ReadOnly"
fileInfo.Attributes &= ~FileAttributes.ReadOnly;
// Impostare più attributi insieme
fileInfo.Attributes = FileAttributes.ReadOnly | FileAttributes.Hidden;
4. Lavorare avanzato con le directory
Ricerca di file con pattern
I metodi GetFiles() e GetDirectories() accettano pattern e aiutano a filtrare il contenuto.
var dir = new DirectoryInfo(@"C:\Projects");
if (dir.Exists)
{
// Trovare tutti i file di testo
var textFiles = dir.GetFiles("*.txt");
Console.WriteLine($"File di testo trovati: {textFiles.Length}");
// Trovare tutti i file che iniziano con "temp"
var tempFiles = dir.GetFiles("temp*");
// Trovare tutte le immagini
var imageExtensions = new[] { "*.jpg", "*.png", "*.gif", "*.bmp" };
var allImages = imageExtensions.SelectMany(ext => dir.GetFiles(ext)).ToArray();
Console.WriteLine($"Immagini trovate: {allImages.Length}");
}
Ricerca ricorsiva nelle sottocartelle
Per scansionare tutte le sottocartelle usa SearchOption.AllDirectories.
var dir = new DirectoryInfo(@"C:\Development");
// Trovare tutti i file C# in tutte le sottocartelle
var csharpFiles = dir.GetFiles("*.cs", SearchOption.AllDirectories);
Console.WriteLine($"Totale file .cs trovati: {csharpFiles.Length}");
// Mostrare i primi 10 file con i loro percorsi
foreach (var file in csharpFiles.Take(10))
{
Console.WriteLine($"{file.FullName} ({FormatFileSize(file.Length)})");
}
Analisi del contenuto di una directory
Esempio di analisi riepilogativa: numero di file/cartelle, dimensione totale, distribuzione per estensioni e top-5 dei file più grandi.
static void AnalyzeDirectory(DirectoryInfo dir)
{
if (!dir.Exists)
{
Console.WriteLine("La directory non esiste!");
return;
}
var files = dir.GetFiles();
var subdirs = dir.GetDirectories();
Console.WriteLine($"Analisi directory: {dir.FullName}");
Console.WriteLine($"File: {files.Length}, Sottodirectory: {subdirs.Length}");
if (files.Length == 0)
{
Console.WriteLine("Nessun file trovato.");
return;
}
long totalSize = files.Sum(f => f.Length);
Console.WriteLine($"Dimensione totale dei file: {FormatFileSize(totalSize)}");
// Raggruppamento per estensioni
var byExtension = files.GroupBy(f => f.Extension.ToLower())
.OrderByDescending(g => g.Sum(f => f.Length));
Console.WriteLine("\nDistribuzione per tipi di file:");
foreach (var group in byExtension)
{
string ext = string.IsNullOrEmpty(group.Key) ? "(senza estensione)" : group.Key;
long groupSize = group.Sum(f => f.Length);
Console.WriteLine($" {ext}: {group.Count()} file, {FormatFileSize(groupSize)}");
}
// Top-5 file più grandi
var largestFiles = files.OrderByDescending(f => f.Length).Take(5);
Console.WriteLine("\nFile più grandi:");
foreach (var file in largestFiles)
{
Console.WriteLine($" {file.Name}: {FormatFileSize(file.Length)}");
}
}
5. Conteggio ottimizzato della dimensione di una directory
Per cartelle grandi invece di GetFiles() usa gli enumeratori lazy EnumerateFiles()/EnumerateDirectories(), gestisci le eccezioni e se vuoi mostra il progresso.
static long GetDirectorySizeAdvanced(DirectoryInfo dir, bool showProgress = false)
{
long totalSize = 0;
int fileCount = 0;
var inaccessibleDirs = new List<string>();
try
{
// Usiamo EnumerateFiles per directory grandi (caricamento lazy)
foreach (var file in dir.EnumerateFiles())
{
try
{
totalSize += file.Length;
fileCount++;
if (showProgress && fileCount % 1000 == 0)
{
Console.WriteLine($"File processati: {fileCount}, dimensione: {FormatFileSize(totalSize)}");
}
}
catch (UnauthorizedAccessException)
{
// File non accessibile, saltiamo
}
catch (IOException)
{
// Problemi nella lettura del file, saltiamo
}
}
// Processiamo ricorsivamente le sottodirectory
foreach (var subdir in dir.EnumerateDirectories())
{
try
{
totalSize += GetDirectorySizeAdvanced(subdir, showProgress);
}
catch (UnauthorizedAccessException)
{
inaccessibleDirs.Add(subdir.FullName);
}
}
}
catch (UnauthorizedAccessException)
{
inaccessibleDirs.Add(dir.FullName);
}
if (inaccessibleDirs.Any() && showProgress)
{
Console.WriteLine($"Directory non accessibili: {inaccessibleDirs.Count}");
}
return totalSize;
}
// Uso
var targetDir = new DirectoryInfo(@"C:\Users");
Console.WriteLine("Inizio calcolo dimensione directory...");
long size = GetDirectorySizeAdvanced(targetDir, showProgress: true);
Console.WriteLine($"Dimensione totale: {FormatFileSize(size)}");
6. Applicazioni pratiche dei metadati
Ricerca file per data
Cerchiamo file modificati in un intervallo di date (utile per pulizie, analisi o audit).
static void FindFilesByDate(DirectoryInfo dir, DateTime fromDate, DateTime toDate)
{
Console.WriteLine($"Ricerca file da {fromDate:yyyy-MM-dd} a {toDate:yyyy-MM-dd}");
var matchingFiles = dir.GetFiles("*", SearchOption.AllDirectories)
.Where(f => f.LastWriteTime >= fromDate && f.LastWriteTime <= toDate)
.OrderByDescending(f => f.LastWriteTime);
Console.WriteLine($"File trovati: {matchingFiles.Count()}");
foreach (var file in matchingFiles.Take(20))
{
Console.WriteLine($"{file.LastWriteTime:yyyy-MM-dd HH:mm} - {file.Name} ({FormatFileSize(file.Length)})");
}
}
// Esempio: trovare tutti i file modificati nell'ultima settimana
var dir = new DirectoryInfo(@"C:\Documents");
var weekAgo = DateTime.Now.AddDays(-7);
FindFilesByDate(dir, weekAgo, DateTime.Now);
Ricerca di file duplicati
Metodo veloce: raggruppare per dimensione. Per maggiore accuratezza puoi aggiungere confronto degli hash del contenuto.
static void FindPotentialDuplicates(DirectoryInfo dir)
{
Console.WriteLine($"Ricerca potenziali duplicati in {dir.FullName}");
var files = dir.GetFiles("*", SearchOption.AllDirectories)
.Where(f => f.Length > 0) // Escludiamo file vuoti
.GroupBy(f => f.Length)
.Where(g => g.Count() > 1) // Solo gruppi con più file
.OrderByDescending(g => g.Key); // Ordiniamo per dimensione
foreach (var sizeGroup in files.Take(10))
{
Console.WriteLine($"\nFile di dimensione {FormatFileSize(sizeGroup.Key)} ({sizeGroup.Count()} pezzi):");
foreach (var file in sizeGroup)
{
Console.WriteLine($" {file.FullName}");
Console.WriteLine($" Modificato: {file.LastWriteTime:yyyy-MM-dd HH:mm:ss}");
}
}
}
Monitoraggio delle modifiche in una directory
Mostriamo i file modificati negli ultimi N minuti.
static void MonitorRecentChanges(DirectoryInfo dir, int minutesBack = 60)
{
var cutoffTime = DateTime.Now.AddMinutes(-minutesBack);
var recentFiles = dir.GetFiles("*", SearchOption.AllDirectories)
.Where(f => f.LastWriteTime > cutoffTime)
.OrderByDescending(f => f.LastWriteTime);
Console.WriteLine($"File modificati negli ultimi {minutesBack} minuti:");
if (!recentFiles.Any())
{
Console.WriteLine("Nessuna modifica trovata.");
return;
}
foreach (var file in recentFiles)
{
var minutesAgo = (DateTime.Now - file.LastWriteTime).TotalMinutes;
Console.WriteLine($"{file.Name} - {minutesAgo:F0} min fa ({FormatFileSize(file.Length)})");
}
}
7. Lavorare con le directory padre
La proprietà Directory di FileInfo e Parent di DirectoryInfo permettono di salire nella gerarchia.
var file = new FileInfo(@"C:\Projects\MyApp\src\Program.cs");
Console.WriteLine($"File: {file.Name}");
Console.WriteLine($"Cartella: {file.Directory.Name}");
Console.WriteLine($"Cartella padre: {file.Directory.Parent.Name}");
Console.WriteLine($"Cartella root del progetto: {file.Directory.Parent.Parent.Name}");
// Si può salire fino alla root
var currentDir = file.Directory;
while (currentDir.Parent != null)
{
Console.WriteLine($"Livello: {currentDir.Name}");
currentDir = currentDir.Parent;
}
Console.WriteLine($"Root: {currentDir.Name}");
8. Trappole ed errori comuni
1. Caching. Gli oggetti FileInfo e DirectoryInfo cachano i valori. Se l'oggetto è cambiato dopo la creazione, i dati possono essere obsoleti. Usa Refresh() per aggiornare.
var file = new FileInfo("test.txt");
file.Refresh(); // Aggiorna i metadati
2. Eccezioni di accesso. Alcuni file e cartelle non sono accessibili: gestisci UnauthorizedAccessException e altri errori di accesso.
try
{
var files = new DirectoryInfo(path).GetFiles();
}
catch (UnauthorizedAccessException)
{
Console.WriteLine("Accesso negato");
}
3. Timestamp. Durante la copia CreationTime può cambiare, mentre LastWriteTime può restare. Questo influisce su report e algoritmi di sincronizzazione.
File.Copy("a.txt", "b.txt");
4. Performance. GetFiles() carica tutto in memoria e può rallentare su cartelle grandi. Preferisci EnumerateFiles() per enumerazione lazy.
GO TO FULL VERSION