Concetto di file, file system e percorso

1. Introduzione

File — è semplicemente un blocco di dati che fisicamente sta su qualche memoria: hard disk, SSD, chiavetta USB, o anche su un floppy disk (saluta tuo nonno!). Per l'utente un file è qualcosa che puoi aprire, leggere, modificare e salvare.

In programmazione un file è una sequenza di byte con un certo nome e posizione, e per te, come programmatore, — è un oggetto che ha un nome, un percorso (come un indirizzo), una dimensione, una data di creazione e così via. La cosa più importante: il file è una memoria persistente dei dati. Tutto quello che succede in RAM dopo l'avvio del programma di solito sparisce quando chiudi il programma, ma il file — resta.

Cos'è un file system?

File system — è il modo in cui i file vengono salvati e organizzati sul disco. Risponde alle domande: dove e come trovare un file, chi può accedervi, come sono fatte le cartelle (directory), come trovare il nome del file e il suo contenuto.

Immagina un armadio gigante con tanti cassetti. In ogni cassetto ci possono essere cartelle, e in ogni cartella — documenti (file). Per trovare i tuoi appunti di C#, devi aprire l'armadio, trovare il cassetto giusto, prendere la cartella e dentro — il foglio che ti serve. Così il file system organizza le informazioni.

File system popolari

• NTFS — il file system "nativo" di Windows.
• FAT32, exFAT — per chiavette USB, SD card, dischi esterni.
• EXT4 — molto usato su Linux.
• APFS, HFS+ — macOS.

Per chi programma in C# di solito non è fondamentale: .NET nasconde i dettagli, tu lavori con l'astrazione "file/cartella". Ma a volte sapere qualcosa aiuta. Per esempio, su NTFS puoi usare spazi e molti simboli speciali nei nomi dei file, su FAT32 — no.

2. Come sono fatte le directory (cartelle)

Directory (o cartella) — è un tipo speciale di file che contiene liste di altri file e/o directory. L'albero delle directory (gerarchia dei file) — è proprio il percorso familiare dalla radice al file: per esempio, C:\Users\Ivan\Documents\MyFile.txt.

• Radice — è l'inizio del disco (C:\).
• Dentro — cartelle (sottocartelle), che contengono file o altre cartelle.

Ecco una visualizzazione semplice:

C:\
 └── Users\
     └── Ivan\
         ├── Documents\
         │    └── MyFile.txt
         └── Pictures\
              └── Cat.jpg

3. Cos'è il percorso di un file (file path)?

Percorso di un file — è "l'indirizzo" del file nell'albero delle cartelle. Serve per trovare in modo univoco il file o la cartella che ti interessa.

Percorso assoluto e relativo

• Percorso assoluto: parte dalla radice del file system.
  Windows: C:\Users\Ivan\Documents\MyFile.txt
  Linux/macOS: /home/ivan/Documents/MyFile.txt
• Percorso relativo: parte dalla posizione attuale (directory corrente).
  Per esempio, se il tuo programma parte dalla cartella C:\Users\Ivan, allora il percorso relativo Documents\MyFile.txt porta allo stesso file.

Directory corrente — è un concetto speciale: è il "punto di partenza" per tutti i percorsi relativi. Quando lanci il programma di solito è la cartella dove sta il file .exe, o quella dove hai aperto il terminale.

Schema: Percorso assoluto e relativo

Percorso assoluto                                Percorso relativo

C:\Projects\MyApp\logs\output.txt              logs\output.txt
└─ Radice del disco (C:)                       └─ Relativo a dove parte MyApp

Separatore nei percorsi: \ e /

Su Windows si usa il backslash (\), su Linux/macOS — di solito lo slash (/).

Il .NET moderno supporta entrambi, ma cerca di non mischiarli nello stesso progetto. Per costruire i percorsi usa sempre le API apposite, non concatenare le stringhe a mano.

4. Come il programma vede un file

In .NET hai un sacco di strumenti per lavorare coi file. I principali sono:

• System.IO.File: metodi statici per leggere, scrivere, cancellare, controllare se esiste un file, ecc.
• System.IO.Directory: metodi simili per lavorare con le cartelle.
• System.IO.FileInfo e System.IO.DirectoryInfo: wrapper a oggetti per accedere ai metadati di file/cartelle.
• System.IO.Path: classe helper per lavorare coi percorsi (unire, prendere l'estensione, il nome, ecc).

Qualche esempio

Controllare se esiste un file

using System.IO;

if (File.Exists("data.txt"))
{
    Console.WriteLine("File trovato!");
}
else
{
    Console.WriteLine("File non trovato!");
}

Ottenere la dimensione di un file

var info = new FileInfo("data.txt");
Console.WriteLine($"Dimensione del file: {info.Length} byte");

Vedremo tutti questi esempi nelle prossime lezioni. Per ora — dai solo un'occhiata e goditeli :)

5. Dettagli utili

Metadati del file: nome, estensione, dimensione, date ecc.

Quando lavori con un file, non ti interessa solo il contenuto — c'è anche il "passaporto del file":

• Nome — come si chiama il file per una persona.
• Estensione — .txt, .jpg, .exe, .cs ecc.: aiuta (a volte!) a capire cosa c'è dentro.
• Dimensione — quanti byte occupa.
• Data di creazione/modifica — puoi sapere quando è stato creato o modificato l'ultima volta.
• Attributi — per esempio: file di sola lettura, nascosto, di sistema.

In .NET per lavorare con questi dati sono comodi i classi FileInfo, DirectoryInfo (li vedremo in una delle prossime lezioni).

Estensioni dei file e formati

Estensione del file — è solo una parte del nome dopo il punto. Per esempio, document.txt ha estensione txt. Il sistema operativo usa l'estensione per capire con cosa "aprire" il file (tipo, .jpg — programma per immagini, .xls — Excel, ecc).

Ma per il programmatore l'estensione — è solo un indizio. Il vero formato del file è determinato solo dal contenuto. Puoi anche aprire MyCat.jpg come testo — e vedrai un sacco di "caratteri strani" (simboli incomprensibili, ma non un'immagine). Quindi ricordati sempre: l'estensione — non è una garanzia, solo una convenzione.

Come funziona la lettura e scrittura di un file: concetti base

Un file — è una sequenza di byte. Lavorare con un file in C# di solito vuol dire:

• Aprire il file per leggere o scrivere (o entrambi).
• Leggere i dati in memoria.
• Scrivere nuovi dati sul disco.
• Chiudere il file — importantissimo, altrimenti tieni bloccata una risorsa di sistema (e qualcuno non potrà cancellare il file finché lo tieni aperto).

Le API moderne di .NET ti aiutano: per esempio, la classe File apre, legge e chiude subito il file. Ma se lavori con stream (Stream) e file grandi, devi stare attento (ne parleremo nelle prossime lezioni).

Cosa sapere sulla cross-platform

Quasi tutto il C# moderno gira su Windows, Linux e macOS praticamente allo stesso modo. Ma ci sono delle differenze. La più comune — è la differenza nei separatori (\ vs /), e anche limiti sulla lunghezza del nome file e simboli vietati.

Ecco perché API come Path.Combine e i metodi di System.IO.Path — sono i tuoi migliori amici. Loro "incollano" il percorso giusto su ogni OS. Mai scrivere così:

var filePath = "C:\\Users\\Ivan\\data.txt"; // Solo per Windows!

Meglio così:

var filePath = Path.Combine("Users", "Ivan", "data.txt");

Come scoprire la directory di lavoro attuale?

A volte è importante capire dove verranno salvati i tuoi file. Per questo c'è una classe speciale:

string currentDir = Environment.CurrentDirectory;
Console.WriteLine($"Directory corrente: {currentDir}");

Tra l'altro, se vuoi far scegliere all'utente il percorso, usa i dialog per scegliere file/cartella o gli argomenti da linea di comando.