.NET Framework
System.IO.File-klasse

Syntaxis

• stringbron;
• string bestemming;

parameters

Verwijder een bestand

Een bestand verwijderen (als u vereiste machtigingen hebt) is zo eenvoudig als:

File.Delete(path);

Er kunnen echter veel dingen misgaan:

• U hebt geen vereiste machtigingen ( UnauthorizedAccessException wordt gegenereerd).
• Bestand kan door iemand anders worden gebruikt ( IOException wordt gegenereerd).
• Bestand kan niet worden verwijderd vanwege een fout van laag niveau of media is alleen-lezen ( IOException wordt gegenereerd).
• Bestand bestaat niet meer ( IOException wordt gegenereerd).

Merk op dat het laatste punt (bestand bestaat niet) meestal wordt omzeild met een codefragment als dit:

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

Het is echter geen atomaire bewerking en het bestand kan door iemand anders worden verwijderd tussen de aanroep van File.Exists() en vóór File.Delete() . Juiste aanpak om I / O-bewerking te verwerken vereist uitzonderingsbehandeling (ervan uitgaande dat een alternatieve manier van handelen kan worden ondernomen wanneer de bewerking mislukt):

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
    }
}

Merk op dat deze I / O-fouten soms tijdelijk zijn (bijvoorbeeld een bestand dat wordt gebruikt) en als er een netwerkverbinding bij betrokken is, kan deze automatisch herstellen zonder enige actie van onze kant. Het is dan gebruikelijk om een I / O-bewerking een paar keer opnieuw te proberen met een kleine vertraging tussen elke poging:

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

Opmerking: in een Windows-omgeving wordt het bestand niet echt verwijderd wanneer u deze functie FileShare.Delete . Als iemand anders het bestand opent met FileShare.Delete kan het bestand worden verwijderd, maar dit gebeurt alleen als de eigenaar het bestand sluit.

Strip ongewenste lijnen uit een tekstbestand

Het wijzigen van een tekstbestand is niet eenvoudig omdat de inhoud moet worden verplaatst. Voor kleine bestanden is de eenvoudigste methode om de inhoud in het geheugen te lezen en vervolgens gewijzigde tekst terug te schrijven.

In dit voorbeeld lezen we alle regels uit een bestand en laten we alle lege regels vallen en schrijven we terug naar het oorspronkelijke pad:

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

Als het bestand te groot is om het in het geheugen te laden en het uitvoerpad verschilt van het invoerpad:

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

Converteer tekstbestandcodering

Tekst wordt gecodeerd opgeslagen (zie ook het onderwerp Strings ) en soms moet u de codering wijzigen. In dit voorbeeld wordt ervan uitgegaan (voor de eenvoud) dat het bestand niet te groot is en volledig in het geheugen kan worden gelezen:

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

Vergeet bij het uitvoeren van conversies niet dat het bestand BOM kan bevatten (Byte Order Mark), om beter te begrijpen hoe het wordt beheerd, raadpleeg Encoding.UTF8.GetString houdt geen rekening met de Preamble / BOM .

"Raak" een groot aantal bestanden aan (om de laatste schrijftijd bij te werken)

Dit voorbeeld werkt de laatste schrijftijd van een groot aantal bestanden bij (met behulp van System.IO.Directory.EnumerateFiles plaats van System.IO.Directory.GetFiles() ). Optioneel kunt u een zoekpatroon opgeven (standaard is "*.*" En uiteindelijk zoeken in een mapstructuur (niet alleen de opgegeven map):

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);
    }
}

Bestanden opsommen die ouder zijn dan een opgegeven hoeveelheid

Dit fragment is een helpfunctie om alle bestanden te inventariseren die ouder zijn dan een opgegeven leeftijd, het is bijvoorbeeld handig wanneer u oude logbestanden of oude gegevens in het cachegeheugen moet verwijderen.

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);
}

Zo gebruikt:

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

Enkele dingen om op te merken:

• Zoeken wordt uitgevoerd met Directory.EnumerateFiles() plaats van Directory.GetFiles() . Opsomming leeft dan zul je niet hoeft te wachten totdat alle file system data opgehaald zijn geweest.
• We controleren op de laatste schrijftijd, maar u kunt de aanmaaktijd of de laatste toegangstijd gebruiken (bijvoorbeeld om ongebruikte bestanden in de cache te verwijderen , houd er rekening mee dat de toegangstijd mogelijk is uitgeschakeld).
• Granulariteit is niet uniform voor al die eigenschappen (schrijftijd, toegangstijd, aanmaaktijd), check MSDN voor details hierover.

Verplaats een bestand van de ene locatie naar de andere

File.Move

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

Er zijn echter veel dingen die mis kunnen gaan met deze eenvoudige bediening. Wat gebeurt er bijvoorbeeld als de gebruiker die uw programma uitvoert geen schijf heeft met het label 'C'? Wat als ze dat deden - maar ze besloten het te hernoemen naar 'B' of 'M'?

Wat als het bronbestand (het bestand waarin u wilt verplaatsen) is verplaatst zonder dat u het weet - of wat als het gewoon niet bestaat.

Dit kan worden omzeild door eerst te controleren of het bronbestand bestaat:

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

Dit zorgt ervoor dat het bestand op dat moment bestaat en naar een andere locatie kan worden verplaatst. Er kunnen momenten zijn waarop een eenvoudige aanroep naar File.Exists niet genoeg zal zijn. Als dit niet het geval is, controleer dan opnieuw, laat de gebruiker weten dat de bewerking is mislukt - of behandel de uitzondering.

Een FileNotFoundException is niet de enige uitzondering die u waarschijnlijk tegenkomt.

Zie hieronder voor mogelijke uitzonderingen: