Suppression de fichiers temporaires après utilisation

StackOverflow https://stackoverflow.com/questions/659351

  •  20-08-2019
  •  | 
  •  

Question

Je dois travailler avec des fichiers temporaires dans mon application Windows Forms .NET 3.5. Ces fichiers sont ouverts dans une application externe qui peut naturellement fonctionner plus longtemps que mon propre programme.

Existe-t-il des pratiques recommandées pour vous assurer que ces fichiers temporaires sont nettoyés à tout moment, afin d'éviter de remplir le disque dur de l'utilisateur avec des "fichiers indésirables"? fichiers qui ne sont plus nécessaires? Ou même Windows gère-t-il cela automatiquement?

Tout client de messagerie est un bon exemple. Lorsque vous ouvrez une pièce jointe dans une application, elle est généralement écrite dans un fichier temporaire qui est ouvert. Existe-t-il un moyen de savoir comment ces fichiers gèrent le nettoyage?

L’utilisation de Google m’a montré de nombreux outils de nettoyage et de mise au point pour nettoyer manuellement le répertoire temporaire, mais je ne voudrais pas forcer les utilisateurs à le faire. : -)

Toute aide est appréciée.

Matthias

Était-ce utile?

La solution

Si vous essayez d'effacer de manière déterministe le contenu d'un dossier de type Fichiers temporaires, vous risquez de supprimer les fichiers en cours d'utilisation par d'autres processus. Le système d'exploitation Windows fournit des outils permettant aux utilisateurs de supprimer ces fichiers lorsque l'espace disque disponible du volume atteint un certain seuil.

Maintenant, si vous pouvez déterminer qu'après avoir utilisé un fichier temporaire spécifique, il ne sera plus nécessaire, il n'y a aucun inconvénient à supprimer ce fichier spécifique.

Autres conseils

Dans .NET, vous pouvez utiliser le TempFileCollection pour la gestion d'un ensemble de fichiers temporaires à nettoyer par votre application (notez qu'il est plutôt masqué dans l'espace de noms CodeDom). Évidemment, vous ne pouvez pas supprimer les fichiers qui ne vous appartiennent pas, car ils pourraient toujours être ouverts par une autre application (et leur suppression pourrait causer de graves problèmes).

La responsabilité du nettoyage des fichiers temporaires doit incomber à l'application qui les a créés. C'est très facile. J'utilise une classe qui ressemble à quelque chose comme ça: 

public class TempFile : IDisposable
{
    public TempFile()
    { this.path = System.IO.Path.GetTempFileName(); }

    public void Dispose()
    { File.Delete(path); }

    private string path;
    public string Path { get { return path; } }
}

Si vous devez nettoyer les fichiers temporaires d'une autre application, vous devez disposer d'un moyen de communication avec le vôtre. Au minimum, il devrait pouvoir fournir un sémaphore. Cependant, la complexité de cette opération est plus grande que celle consistant à demander à l'application d'origine de gérer ses propres fichiers.

Nous rencontrons un problème similaire concernant la durée de vie des fichiers: l'application (winforms) peut extraire un document d'un magasin de référentiel central pour que l'utilisateur puisse l'afficher, mais l'utilisateur devrait pouvoir fermer notre application sans que cela affecte le fichier visualisé. Pour des raisons de sécurité, les fichiers de documents doivent être nettoyés afin de ne pas les traîner trop longtemps.

La solution que nous utilisons consiste à créer un dossier avec un nom dérivé de la date dans la zone de stockage isolée des utilisateurs et à l'utiliser comme cache actuel. Lors de la fermeture et du démarrage de l'application, nous vérifions la présence de dossiers de cache antérieurs et les supprimons (ainsi que leur contenu).

Je pense qu'ils seront supprimés lorsque l'utilisateur se déconnectera.

À l'époque où les gens éteignaient leur ordinateur tous les jours, c'était probablement une solution parfaite.

Maintenant, les gens peuvent potentiellement passer des mois sans se déconnecter, alors ce n’est peut-être pas une bonne idée de s’en remettre à cela.

En outre, s’ils éteignent leur ordinateur sans s’arrêter, les fichiers ne seront pas supprimés non plus.

Vous pouvez utiliser un observateur du système de fichiers qui surveille le fichier que vous écrivez et attendez une période d’inactivité (10 minutes, 1 heure, 1 jour ou quoi que ce soit), puis supprimez le fichier.

Cela ne fonctionnera pas pour tout bien. Certains programmes peuvent avoir un fichier "ouvert", mais le fichier sous-jacent peut ne pas être verrouillé. Si cela se produit, vous n’aurez aucun moyen de savoir s’il est sans danger de supprimer le fichier.

Cependant, je pense que vous pouvez probablement simplement ignorer le problème. De toute façon, la plupart des gens ont probablement un surplus d’espace disque dur, de sorte qu’ils ne risquent probablement pas de le rencontrer. Si tel est le cas, je pense que Windows affiche une boîte de dialogue d'espace disque insuffisant qui lui donne la possibilité de vider son répertoire temporaire, ce qui résoudrait le problème.

Mise à jour:

Je pense que Windows Update redémarre l'ordinateur de l'utilisateur environ une fois par mois. Par conséquent, les fichiers temporaires doivent être effacés lorsque cela se produit.

Rien ne garantit qu'il n'y aura pas de problèmes, mais en pratique, je pense que cela devrait être assez rare.

Mise à jour 2:

Invité par un commentaire, je suis allé le tester et il semble que Windows ne supprime pas les fichiers temporaires lorsque l'utilisateur se déconnecte. Cependant, je continue de dire que dans le cas du PO, ce n'est pas un réel problème. Lorsque cela devient un problème (l'espace disque étant insuffisant), Windows invite l'utilisateur à supprimer les fichiers temporaires.

Lors de l'utilisation de fichiers temporaires dans ASP.NET, utilisez l'événement PAGE_DISPOSED pour supprimer les fichiers temporaires créés dans la page. Sinon, vous risquez de vous retrouver avec des composants qui ne lâcheront pas avant d'avoir été JETÉS.

J'utilise cette solution (assez fiable): 

using System.IO;
using System.Reflection;

namespace Konard.Helpers
{
    public static partial class TemporaryFiles
    {
        private const string UserFilesListFilenamePrefix = ".used-temporary-files.txt";
        static private readonly object UsedFilesListLock = new object();

        private static string GetUsedFilesListFilename()
        {
            return Assembly.GetEntryAssembly().Location + UserFilesListFilenamePrefix;
        }

        private static void AddToUsedFilesList(string filename)
        {
            lock (UsedFilesListLock)
            {
                using (var writer = File.AppendText(GetUsedFilesListFilename()))
                    writer.WriteLine(filename);
            }
        }

        public static string UseNew()
        {
            var filename = Path.GetTempFileName();
            AddToUsedFilesList(filename);
            return filename;
        }

        public static void DeleteAllPreviouslyUsed()
        {
            lock (UsedFilesListLock)
            {
                var usedFilesListFilename = GetUsedFilesListFilename();

                if (!File.Exists(usedFilesListFilename))
                    return;

                using (var listFile = File.Open(usedFilesListFilename, FileMode.Open))
                {
                    using (var reader = new StreamReader(listFile))
                    {
                        string tempFileToDelete;
                        while ((tempFileToDelete = reader.ReadLine()) != null)
                        {
                            if (File.Exists(tempFileToDelete))
                                File.Delete(tempFileToDelete);
                        }
                    }
                }

                // Clean up
                using (File.Open(usedFilesListFilename, FileMode.Truncate)) { }
            }
        }
    }
}

Chaque fois que vous avez besoin d'un fichier temporaire: 

var tempFile = TemporaryFiles.UseNew();

Pour vous assurer que tous les fichiers temporaires sont supprimés après la fermeture ou le blocage de l'application 

TemporaryFiles.DeleteAllPreviouslyUsed();

au début de l'application.

  • vous pouvez créer un fichier temporaire, dans lequel vous pouvez continuer à écrire les noms de fichier créés au cours du processus. À la fin du traitement, vous pouvez éventuellement (condition préalable - implémenter IDisposable et) supprimer dans la méthode Disponse après opération. est terminée.

  • L'autre méthode est un processus indépendant de l'écriture, qui effectue le nettoyage à chaque intervalle.

  • Joignez la date à la fin du fichier, supprimez-la à la fin de la journée et le processus générera les nouveaux fichiers avec la nouvelle date à la fin.

  • une bonne suggestion donnée par la classe divo tempfilecollection.

espérons que cela aide.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top