CodeGym /Corsi /C# SELF /Ottenere informazioni su file e directory

Ottenere informazioni su file e directory

C# SELF
Livello 39, Lezione 2
Disponibile

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
C:\data\myfile.txt
Nome Nome senza percorso
myfile.txt
Estensione .txt, .csv, .jpg ecc.
.txt
Dimensione (Bytes) Dimensione del file in byte
4096
Data di creazione Quando è stato creato il file/cartella
2024-04-16 19:30:10
Data di modifica Quando è stato modificato l'ultima volta il contenuto
2024-05-01 18:14:02
Attributi Per esempio, sola lettura, nascosto ecc.
ReadOnly, Hidden
Cartella padre La cartella che contiene il file/directory
C:\data

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.

2
Compito
C# SELF, livello 39, lezione 2
Bloccato
Esplorazione del contenuto di una directory
Esplorazione del contenuto di una directory
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION