.NET Framework
System.IO.File class

Sintassi

• fonte di stringhe;
• destinazione stringa;

Parametri

Elimina un file

Cancellare un file (se hai le autorizzazioni richieste) è semplice come:

File.Delete(path);

Tuttavia molte cose potrebbero andare storte:

• Non hai le autorizzazioni necessarie (viene lanciata UnauthorizedAccessException ).
• Il file potrebbe essere in uso da qualcun altro (viene lanciata IOException ).
• Il file non può essere eliminato a causa di un errore di basso livello o il supporto è di sola lettura (viene generata IOException ).
• Il file non esiste più (viene lanciata IOException ).

Nota che l'ultimo punto (il file non esiste) viene solitamente aggirato con uno snippet di codice come questo:

if (File.Exists(path))
    File.Delete(path);

Tuttavia non è un'operazione atomica e il file potrebbe essere eliminato da qualcun altro tra la chiamata a File.Exists() e prima di File.Delete() . L'approccio corretto per gestire le operazioni di I / O richiede la gestione delle eccezioni (presupponendo che una procedura alternativa possa essere intrapresa quando l'operazione fallisce):

if (File.Exists(path))
{
    try
    {
        File.Delete(path);
    }
    catch (IOException exception)
    {
        if (!File.Exists(path))
            return; // Someone else deleted this file

        // Something went wrong...
    }
    catch (UnauthorizedAccessException exception)
    {
        // I do not have required permissions
    }
}

Si noti che questi errori di I / O a volte sono transitori (file in uso, ad esempio) e se è coinvolta una connessione di rete, può automaticamente ripristinarsi senza alcuna azione da parte nostra. È quindi normale riprovare un'operazione di I / O alcune volte con un piccolo ritardo tra ogni tentativo:

public static void Delete(string path)
{
    if (!File.Exists(path))
        return;

    for (int i=1; ; ++i)
    {
        try
        {
            File.Delete(path);
            return;
        }
        catch (IOException e)
        {
            if (!File.Exists(path))
                return;

            if (i == NumberOfAttempts)
                throw;

            Thread.Sleep(DelayBetweenEachAttempt);
        }

        // You may handle UnauthorizedAccessException but this issue
        // will probably won't be fixed in few seconds...
    }
}

private const int NumberOfAttempts = 3;
private const int DelayBetweenEachAttempt = 1000; // ms

Nota: in Windows il file di ambiente non verrà realmente cancellato quando si chiama questa funzione, se qualcun altro apre il file utilizzando FileShare.Delete allora il file può essere cancellato ma in realtà si verifica solo quando il proprietario chiude il file.

Striscia le linee indesiderate da un file di testo

Cambiare un file di testo non è facile perché il suo contenuto deve essere spostato. Per i file di piccole dimensioni, il metodo più semplice è leggerne il contenuto in memoria e quindi riscrivere il testo modificato.

In questo esempio leggiamo tutte le linee da un file e rilasciamo tutte le righe vuote, quindi scriviamo di nuovo sul percorso originale:

File.WriteAllLines(path,
    File.ReadAllLines(path).Where(x => !String.IsNullOrWhiteSpace(x)));

Se il file è troppo grande per caricarlo in memoria e il percorso di output è diverso dal percorso di input:

File.WriteAllLines(outputPath,
    File.ReadLines(inputPath).Where(x => !String.IsNullOrWhiteSpace(x)));

Converti la codifica dei file di testo

Il testo viene salvato codificato (vedi anche argomento Stringhe ), quindi a volte potrebbe essere necessario modificare la codifica, in questo esempio si presuppone (per semplicità) che il file non sia troppo grande e possa essere letto interamente in memoria:

public static void ConvertEncoding(string path, Encoding from, Encoding to)
{
    File.WriteAllText(path, File.ReadAllText(path, from), to);
}

Quando si eseguono le conversioni non dimenticare che il file può contenere BOM (Byte Order Mark), per capire meglio come viene gestito fare riferimento a Encoding.UTF8.GetString non tiene conto del Preamble / BOM .

"Tocca" una grande quantità di file (per aggiornare l'ultima ora di scrittura)

Questo esempio aggiorna l'ultimo tempo di scrittura di un numero enorme di file (utilizzando System.IO.Directory.EnumerateFiles anziché System.IO.Directory.GetFiles() ). Opzionalmente è possibile specificare un modello di ricerca (il valore predefinito è "*.*" E alla fine cercare attraverso un albero di directory (non solo la directory specificata):

public static void Touch(string path,
                         string searchPattern = "*.*",
                         SearchOptions options = SearchOptions.None)
{
    var now = DateTime.Now;

    foreach (var filePath in Directory.EnumerateFiles(path, searchPattern, options))
    {
        File.SetLastWriteTime(filePath, now);
    }
}

Enumerare i file più vecchi di una quantità specificata

Questo snippet è una funzione di supporto per enumerare tutti i file più vecchi di un'età specificata, è utile, ad esempio, quando è necessario eliminare vecchi file di registro o vecchi dati memorizzati nella cache.

static IEnumerable<string> EnumerateAllFilesOlderThan(
                               TimeSpan maximumAge,
                               string path,
                               string searchPattern = "*.*",
                               SearchOption options = SearchOption.TopDirectoryOnly)
{
    DateTime oldestWriteTime = DateTime.Now - maximumAge;

    return Directory.EnumerateFiles(path, searchPattern, options)
        .Where(x => Directory.GetLastWriteTime(x) < oldestWriteTime);
}

Usato in questo modo:

var oldFiles = EnumerateAllFilesOlderThan(TimeSpan.FromDays(7), @"c:\log", "*.log");

Poche cose da notare:

• La ricerca viene eseguita utilizzando Directory.EnumerateFiles() anziché Directory.GetFiles() . L'enumerazione è attiva, quindi non è necessario attendere fino a quando tutte le voci del file system sono state recuperate.
• Stiamo controllando l'ora dell'ultima scrittura, ma è possibile utilizzare il tempo di creazione o l'ultimo orario di accesso (ad esempio per eliminare i file memorizzati in cache, si noti che il tempo di accesso potrebbe essere disabilitato).
• La granularità non è uniforme per tutte queste proprietà (tempo di scrittura, tempo di accesso, tempo di creazione), controllare MSDN per dettagli su questo.

Sposta un file da una posizione a un'altra

File.Move

File.Move(@"C:\TemporaryFile.txt", @"C:\TemporaryFiles\TemporaryFile.txt");

Tuttavia, ci sono molte cose che potrebbero andare storte con questa semplice operazione. Ad esempio, cosa succede se l'utente che esegue il programma non ha un'unità con l'etichetta "C"? E se lo facessero, ma hanno deciso di rinominarlo in "B" o "M"?

Cosa succede se il file di origine (il file in cui desideri spostarti) è stato spostato a tua insaputa - o se semplicemente non esiste.

Questo può essere aggirato verificando prima se il file sorgente esiste:

string source = @"C:\TemporaryFile.txt", destination = @"C:\TemporaryFiles\TemporaryFile.txt";
if(File.Exists("C:\TemporaryFile.txt"))
{
    File.Move(source, destination);
}

Ciò assicurerà che in quel preciso istante il file esista e possa essere spostato in un'altra posizione. Ci possono essere momenti in cui una semplice chiamata a File.Exists non sarà sufficiente. In caso contrario, ricontrollare, comunicare all'utente che l'operazione non è riuscita o gestire l'eccezione.

Una eccezione FileNotFoundException non è l'unica che è probabile incontrare.

Vedi sotto per possibili eccezioni: