Los archivos temporales en .Net

Question

Es necesario crear algunos mapas de bits y guardarlos en el sistema de archivos. Por alguna razón el sistema MScharting quiere es archivos de fondo suministros como trayectorias en forma de cadena.

Estoy creando dinámicamente la imagen de fondo, aunque sólo unas pocas veces.

¿Cuál es la mejor manera de crear estos archivos y luego limpiarlos?

Answer 1

Su mejor opción es tener un TemporaryFileManager que implementa IDisposable; usted lo pide para los archivos temporales, que se genera automáticamente y se pega en un directorio temporal en algún lugar, a continuación, todos ellos se eliminan cuando el TemporaryFileManager se dispone, ya sea por usted o el finalizador (si se ha implementado correctamente el patrón desechable)

Answer 2

Así es como se puede obtener la ruta completa y el nombre de un archivo temporal:

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

Crea el archivo con este nombre de archivo y ruta de acceso y cuando haya terminado eliminarlo.

Answer 3

En mis proyectos, tengo una clase de ayuda llamada de archivo temporal. Tiene varios métodos estáticos que utilizo para escribir una corriente (o una matriz de bytes si es necesario) a un archivo temporal. Aquí está un ejemplo simplificado de un método de este tipo:

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

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

   return FileName;
}

A continuación, tengo otro método que acepta una ruta de archivo para su posterior eliminación, que es un miembro de mi clase 'análisis', aunque se podría ponerlo en su propia clase auxiliar estática:

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

   return path;
}

Por último, hago lo siguiente:

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

Esta es la mejor manera que he llegado con para eludir la falta de capacidad de manejo de corriente de un API.

Answer 4

Yo uso esta solución:

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

Cada vez que necesite el uso de archivos temporales:

var tempFile = TemporaryFiles.UseNew();

Para asegurarse de que todos los archivos temporales se eliminan después de la aplicación se cierra o se bloquea puso

TemporaryFiles.DeleteAllPreviouslyUsed();

al inicio de la aplicación.