.NET Framework
Classe System.IO.File

Syntaxe

• source de chaîne;
• destination de chaîne;

Paramètres

Supprimer un fichier

Supprimer un fichier (si vous avez les autorisations requises) est aussi simple que:

File.Delete(path);

Cependant, beaucoup de choses peuvent mal tourner:

• Vous n'avez pas les autorisations requises (une UnauthorizedAccessException est levée).
• Le fichier peut être utilisé par quelqu'un d'autre ( IOException est lancé).
• Le fichier ne peut pas être supprimé en raison d'une erreur de bas niveau ou d'un support en lecture seule ( IOException est IOException ).
• Le fichier n'existe plus ( IOException est IOException ).

Notez que le dernier point (le fichier n'existe pas) est généralement contourné avec un extrait de code comme celui-ci:

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

Cependant, ce n'est pas une opération atomique et le fichier peut être supprimé par quelqu'un d'autre entre l'appel à File.Exists() et avant File.Delete() . L'approche appropriée pour gérer les opérations d'E / S nécessite la gestion des exceptions (en supposant qu'une autre procédure puisse être prise en cas d'échec de l'opération):

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

Notez que ces erreurs d'E / S sont parfois transitoires (fichier en cours d'utilisation, par exemple) et qu'une connexion réseau est impliquée, elle peut alors se rétablir automatiquement sans aucune action de notre part. Il est alors courant de réessayer plusieurs fois une opération d'E / S avec un léger délai entre chaque tentative:

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

Remarque: dans l'environnement Windows, le fichier ne sera pas réellement effacé lorsque vous appelez cette fonction, si quelqu'un d'autre ouvre le fichier en utilisant FileShare.Delete alors le fichier peut être supprimé mais cela ne se produira effectivement que lorsque le propriétaire fermera le fichier.

Supprimer les lignes indésirables d'un fichier texte

Changer de fichier texte n’est pas facile car son contenu doit être déplacé. Pour les petits fichiers, la méthode la plus simple consiste à lire son contenu en mémoire, puis à écrire le texte modifié.

Dans cet exemple, nous lisons toutes les lignes d'un fichier et supprimons toutes les lignes vides, puis nous réécrivons le chemin d'origine:

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

Si le fichier est trop gros pour le charger en mémoire et que le chemin de sortie est différent du chemin d’entrée:

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

Convertir l'encodage du fichier texte

Le texte est enregistré codé (voir aussi le sujet Chaînes ), parfois vous devrez peut-être modifier son encodage, cet exemple suppose (pour simplifier) ​​que ce fichier n'est pas trop gros et qu'il peut être entièrement lu en mémoire:

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

Lorsque vous effectuez des conversions ne faut pas oublier que le fichier peut contenir BOM (Byte Order Mark), afin de mieux comprendre comment il a réussi à se référer Encoding.UTF8.GetString ne prend pas en compte le préambule / nomenclature .

"Touchez" une grande quantité de fichiers (pour mettre à jour la dernière heure d'écriture)

Cet exemple met à jour la dernière heure d'écriture d'un grand nombre de fichiers (à l'aide de System.IO.Directory.EnumerateFiles au lieu de System.IO.Directory.GetFiles() ). Vous pouvez éventuellement spécifier un modèle de recherche (la valeur par défaut est "*.*" Et éventuellement rechercher dans une arborescence de répertoires (pas uniquement dans le répertoire spécifié):

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

Énumérer les fichiers antérieurs à une quantité spécifiée

Cet extrait de code est une fonction d'assistance permettant d'énumérer tous les fichiers plus anciens qu'un âge spécifié. Il est utile, par exemple, pour supprimer d'anciens fichiers journaux ou d'anciennes données en 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);
}

Utilisé comme ceci:

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

Peu de choses à noter:

• La recherche est effectuée à l'aide de Directory.EnumerateFiles() au lieu de Directory.GetFiles() . L'énumération est active, vous n'avez donc pas besoin d'attendre que toutes les entrées du système de fichiers aient été récupérées.
• Nous vérifions l'heure de la dernière écriture, mais vous pouvez utiliser l'heure de création ou la dernière heure d'accès (par exemple, pour supprimer les fichiers cachés inutilisés , notez que le temps d'accès peut être désactivé).
• La granularité n'est pas uniforme pour toutes ces propriétés (temps d'écriture, temps d'accès, temps de création), consultez MSDN pour plus de détails à ce sujet.

Déplacer un fichier d'un endroit à un autre

File.Move

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

Cependant, il y a beaucoup de choses qui pourraient mal tourner avec cette opération simple. Par exemple, que se passe-t-il si l'utilisateur qui exécute votre programme ne dispose pas d'un lecteur nommé «C»? Et s'ils le faisaient, mais ils ont décidé de le renommer en «B» ou «M»?

Que se passe-t-il si le fichier source (le fichier dans lequel vous souhaitez déplacer) a été déplacé à votre insu - ou s'il n'existe tout simplement pas?

Cela peut être contourné en vérifiant d'abord si le fichier source existe:

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

Cela garantira que le fichier existe à ce moment-là et peut être déplacé vers un autre emplacement. Parfois, un simple appel à File.Exists ne suffira pas. Si ce n'est pas le cas, vérifiez à nouveau, indiquez à l'utilisateur que l'opération a échoué ou gérez l'exception.

Une FileNotFoundException n'est pas la seule exception que vous êtes susceptible de rencontrer.

Voir ci-dessous pour les exceptions possibles: