Creazione e eliminazione di file

1. Introduzione

Può sembrare che un file sia una cosa semplice e crearne uno sia facilissimo: basta cliccare col tasto destro (su Windows). Ma nei progetti reali creare ed eliminare file via codice è la chiave per automazione e flessibilità. Per esempio:

• In un editor di testo l'utente preme "Salva" — e il tuo codice crea un nuovo file dove scrivere il lavoro del poeta.
• Un servizio di logging crea automaticamente file di log all'avvio dell'applicazione.
• Un archiviatore o una utility di backup crea regolarmente file temporanei e poi li elimina.
• Un gioco in C# fa autosave — crea o sovrascrive il file di salvataggio.
• E poi tu (o il tuo script) pulite automaticamente una cartella da vecchi file temporanei per non riempire il disco.

Saper creare ed eliminare file automaticamente è una delle competenze fondamentali di un moderno sviluppatore .NET.

2. Operazioni veloci con File

Creare un file

In C# si può creare un file in diversi modi. Il percorso più rapido e semplice è usare la classe statica File. Proviamo:

// Creiamo un file vuoto "myfile.txt" nella directory corrente
File.Create("myfile.txt").Close(); // FileStream va chiuso!
Console.WriteLine("Il file 'myfile.txt' è stato creato.");

Dettaglio importante:
Il metodo File.Create restituisce un oggetto FileStream che va chiuso (Close()) altrimenti il sistema operativo si lamenterà che il file è "occupato". Senza chiudere il flusso alcune altre operazioni sullo stesso file potrebbero non funzionare. La classica situazione: "File occupato da un altro processo", mentre quel "altro processo" è la stessa tua applicazione che non ha chiuso il stream.

Se il file esisteva già, File.Create lo sovrascrive (il vecchio viene eliminato e ne viene creato uno nuovo e vuoto). Se non esisteva — verrà creato.

E a che serve un file vuoto?

Di solito il file serve per scriverci qualcosa. Per questo ci sono metodi comodi:

File.WriteAllText("welcome.txt", "Ciao, mondo dei file!");

Questo comando crea il file, ci scrive la stringa e chiude tutto in modo pulito (non ci saranno problemi).

Verificare l'esistenza di un file

Prima di creare un file, conviene controllare se non esista già. Altrimenti rischiamo di cancellare qualcosa di importante.

if (!File.Exists("important.txt"))
{
    File.WriteAllText("important.txt", "Salviamo informazioni importanti.");
    Console.WriteLine("File creato.");
}
else
{
    Console.WriteLine("Questo file esiste già, conviene fare qualcosa di diverso!");
}

3. Esempio pratico: "Salviamo il saluto all'utente"

Console.Write("Inserisci il tuo nome: ");
string name = Console.ReadLine();

string filename = $"{name}_greeting.txt";
string message = $"Benvenuto, {name}!";

// Controlliamo se il file esiste
if (!File.Exists(filename))
{
    File.WriteAllText(filename, message);
    Console.WriteLine($"Il file di saluto personale {filename} è stato creato.");
}
else
{
    Console.WriteLine($"Il file {filename} esiste già! Sovrascrivere? (y/n)");
    string answer = Console.ReadLine();
    if (answer?.ToLower() == "y")
    {
        File.WriteAllText(filename, message);
        Console.WriteLine($"Il file {filename} è stato sovrascritto.");
    }
    else
    {
        Console.WriteLine("Lasciamo tutto com'è.");
    }
}

Cosa facciamo qui:

• Controlliamo se il file esiste (File.Exists).
• Se non c'è — lo creiamo e scriviamo il testo (File.WriteAllText).
• Se c'è — chiediamo all'utente se sovrascriverlo.

4. Eliminare un file

Eliminare file in C# è quasi da hacker... ma sicuro! Anche qui è semplice:

Usare File.Delete

File.Delete("myfile.txt");

Se il file non esiste — non succede nulla. Non viene lanciata un'eccezione (se il percorso è corretto).

Trappole per i principianti

• Se il file è già aperto dalla tua applicazione (o da un altro processo), verrà lanciata un'eccezione.
• Se il percorso è sbagliato — apparirà un ArgumentException.

Raccomandazione: verifica sempre l'esistenza

if (File.Exists("victim.txt"))
{
    File.Delete("victim.txt");
    Console.WriteLine("File eliminato.");
}
else
{
    Console.WriteLine("Non c'è niente da eliminare — quel file non è stato trovato.");
}

5. Cartelle e file: creiamo una struttura

Creare un file dentro una cartella

string folder = "Data";
Directory.CreateDirectory(folder); // se la cartella non esiste — verrà creata

string filename = Path.Combine(folder, "info.txt");
File.WriteAllText(filename, "Qui è conservato un messaggio segreto!");

Importante: Tentare di creare un file in una cartella inesistente genererà un'eccezione. Quindi è giusto chiamare prima Directory.CreateDirectory(folder). Non ricreerà la cartella se esiste già, quindi la chiamata è sicura.

6. Lavorare con istanze: FileInfo

Per scenari un po' più "old-school" o avanzati è utile la classe FileInfo:

FileInfo fi = new FileInfo("example.txt");

// Creare un nuovo file (come File.Create — crea un file vuoto)
using (var fs = fi.Create())
{
    // si può scrivere qualcosa, se necessario
}

Console.WriteLine($"Il file 'example.txt' è stato creato usando FileInfo.");

Eliminare tramite FileInfo:

FileInfo fi = new FileInfo("oldfile.txt");
if (fi.Exists)
{
    fi.Delete();
    Console.WriteLine("File eliminato tramite FileInfo.");
}

Vantaggi di FileInfo

Se prevedi di fare non solo creazione/eliminazione, ma anche accedere spesso a proprietà del file o eseguire più azioni, l'approccio basato su istanze è più comodo (e a volte più performante).

7. Creiamo e puliamo i "file tecnici"

Supponiamo che l'app accumuli file temporanei nella cartella "temp_data", e vogliamo eliminare tutti i file in quella cartella i cui nomi iniziano con "temp_".

string tempFolder = "temp_data";
Directory.CreateDirectory(tempFolder);

for (int i = 1; i <= 5; i++)
{
    string tempFile = Path.Combine(tempFolder, $"temp_{i}.txt");
    File.WriteAllText(tempFile, $"Dati di test {i}");
}
Console.WriteLine("5 file temporanei creati.");

// Ora eliminiamo tutti i temp_*.txt
foreach (string file in Directory.GetFiles(tempFolder, "temp_*.txt"))
{
    File.Delete(file);
    Console.WriteLine($"Eliminato file: {file}");
}

Funziona alla grande per pulire automaticamente file vecchi e temporanei.

8. Dettagli importanti: eccezioni e sicurezza

Cosa può andare storto:

• Nessun permesso di scrittura/eliminazione nella cartella (per esempio, C:\Windows)
• Il file è già occupato da un altro processo (o dalla tua app)
• Il percorso contiene caratteri non validi (per esempio, *?<>)
• Il file viene eliminato da un altro processo tra il tuo controllo e l'eliminazione (sì, succede!)

Come proteggersi

Nel codice "reale" queste operazioni vanno sempre avvolte in un blocco try-catch:

try
{
    File.Delete("trickyfile.txt");
    Console.WriteLine("File eliminato.");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Nessun permesso per eliminare il file.");
}
catch (IOException ex)
{
    Console.WriteLine("Il file potrebbe essere occupato da un altro processo.");
}
catch (Exception ex)
{
    Console.WriteLine($"Errore: {ex.Message}");
}

9. Suggerimenti utili

File che vanno sempre controllati

• Usa Path.Combine per costruire i percorsi. Così non avrai problemi con slash mancanti o doppi, e il codice sarà cross-platform.
• Controlla l'esistenza del file prima di creare/eliminare se non vuoi sorprese.
• Avvolgi il codice in try-catch se lavori in produzione e, soprattutto, in un'app "multiutente".
• Per operazioni ripetute sullo stesso file usa FileInfo, per operazioni una tantum usa File.
• Non tenere i file aperti più del necessario. Hai un file aperto? Chiediti: "Perché?" e chiudilo! Usa using quando possibile.

Cheat sheet tecnica

File.Create

File.WriteAllText

File.Exists

File.Delete

Directory.CreateDirectory + File.WriteAllText

new FileInfo(path).Create / Delete / Exists

10. Errori tipici nel lavoro con i file

Errore №1: dimenticare di chiudere lo stream dopo File.Create.
Molti principianti creano un file con File.Create ma non chiudono lo stream restituito. Di conseguenza il resto del codice smette di "vedere" il file — come se fosse finito in un universo parallelo. Chiudi lo stream esplicitamente (Close()) o usa la costruzione using.

Errore №2: tentare di creare un file in una cartella inesistente.
Trappola classica — provare a creare un file in una directory che non esiste ancora. Non dimenticare di chiamare Directory.CreateDirectory prima. È assolutamente sicuro: non creerà roba "in più", e la cartella necessaria apparirà.

Errore №3: eliminare un file senza controllo.
A volte si vuole semplicemente chiamare File.Delete senza controllare. Questo va bene — il metodo non lancerà errore se il file non esiste. Ma se il percorso è sbagliato o non hai i permessi — l'eccezione è sicura. Meglio gestirla in anticipo.

Errore №4: confondere File.Delete e Directory.Delete.
File.Delete è per file, Directory.Delete è per cartelle. Cercare di cancellare una cartella con File.Delete è come cercare di lucidare un mattone con uno spazzolino da denti: tecnicamente possibile? No, davvero non ha senso.

2

Compito

C# SELF, livello 40, lezione 0

Bloccato

Creazione e cancellazione di un file in una cartella

Creazione e cancellazione di un file in una cartella

Apri