I file temporanei in .Net

Question

Ho bisogno di creare alcune immagini bitmap e salvarli nel file system. Per qualche motivo il sistema MScharting vuole che sia file di sfondo forniture come percorsi in forma di stringa.

Sto creando dinamicamente l'immagine di sfondo, anche se solo un paio di volte.

Qual è il modo migliore per creare questi file e poi ripulire?

Answer 1

La cosa migliore è quella di avere un TemporaryFileManager che implementa IDisposable; si chiede che per i file temporanei, che si auto-genera e bastoni in una directory temp da qualche parte, poi tutti vengono eliminati quando il TemporaryFileManager viene smaltito, da voi o il finalizzatore (se hai implementato il modello usa e getta correttamente)

Answer 2

Ecco come è possibile ottenere il percorso completo e il nome di un file temporaneo file:

string tempFile = System.IO.Path.GetTempFileName();

Crea il file con il nome del file e il percorso e quando hai finito eliminarlo.

Answer 3

Nei miei progetti, ho una classe di supporto chiamato tempfile. Ha diversi metodi statici che uso per scrivere una corrente (o una matrice di byte se necessario) in un file temporaneo. Ecco un esempio semplificato di un tale metodo:

public static string Write(Stream stream)
{
   string FileName = Path.GetTempFileName();

   // Write the contents of stream to a file with FileName

   return FileName;
}

Poi, ho un altro metodo che accetta un percorso di file per l'eliminazione successiva, che è un membro della mia classe 'analisi', anche se si potrebbe mettere nella propria classe di supporto statica:

public string ForDeletion(string path)
{
   ListOfPaths.Add(path);

   return path;
}

Infine, faccio la seguente:

SomeApiFunction(ForDeletion(TempFile.Write(myStream)));

Questo è il modo migliore che è venuta in mente per aggirare la mancanza di un'API di capacità di gestione del flusso.

Answer 4

Io uso questa soluzione:

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

Ogni volta che si ha bisogno di utilizzare file temporaneo:

var tempFile = TemporaryFiles.UseNew();

Per essere sicuri tutti i file temporanei vengono eliminati dopo l'applicazione si chiude o si blocca messo

TemporaryFiles.DeleteAllPreviouslyUsed();

all'avvio dell'applicazione.