¿Cómo elimino automáticamente los archivos temporales en c#?

Considere usar las opciones de archivo.DeleteOnClose flag:

using (FileStream fs = new FileStream(Path.GetTempFileName(),
       FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None,
       4096, FileOptions.RandomAccess | FileOptions.DeleteOnClose))
{
    // temp file exists
}

// temp file is gone

Podrías P/Invocar CreateFile y pase la bandera FILE_FLAG_DELETE_ON_CLOSE. Esto le dice a Windows que elimine el archivo una vez que todos los controladores estén cerrados. Véase también: Win32 CreateFile docs .

Usaría la clase.NET TempFileCollection, ya que está incorporada, disponible en versiones antiguas de. NET, e implementa la interfaz IDisposable y, por lo tanto, limpia después de sí misma si se usa, por ejemplo, junto con la palabra clave "using".

Aquí hay un ejemplo que extrae texto de un recurso incrustado (agregado a través de la propiedad páginas de proyectos -> Pestaña Recursos como se describe aquí: ¿Cómo incrustar un archivo de texto en un ensamblado. NET?, luego establezca "EmbeddedResource" en la configuración de propiedades del archivo incrustado).

    // Extracts the contents of the embedded file, writes them to a temp file, executes it, and cleans up automatically on exit.
    private void ExtractAndRunMyScript()
    {
        string vbsFilePath;

        // By default, TempFileCollection cleans up after itself.
        using (var tempFiles = new System.CodeDom.Compiler.TempFileCollection())
        {
            vbsFilePath= tempFiles.AddExtension("vbs");

            // Using IntelliSense will display the name, but it's the file name
            // minus its extension.
            System.IO.File.WriteAllText(vbsFilePath, global::Instrumentation.Properties.Resources.MyEmbeddedFileNameWithoutExtension);

            RunMyScript(vbsFilePath);
        }

        System.Diagnostics.Debug.Assert(!File.Exists(vbsFilePath), @"Temp file """ + vbsFilePath+ @""" has not been deleted.");
    }

No soy principalmente un programador de C#, pero en C++ usaría RAII para esto. Hay algunas sugerencias sobre el uso de un comportamiento similar a RAII en C# en línea, pero la mayoría parecen usar el finalizer, que no es determinista.

Creo que hay algunas funciones del SDK de Windows para crear archivos temporales, pero no sé si se eliminan automáticamente al finalizar el programa. Existe la función GetTempPath , pero los archivos allí solo se eliminan cuando cierra la sesión o reinicia, IIRC.

P.d. La documentación de C# destructor dice que puede y debe liberar recursos allí, lo que me parece un poco extraño. Si es así, simplemente podría eliminar el archivo temporal en el destructor, pero de nuevo, esto podría no ser completamente determinista.

Es bueno ver que quieres ser responsable, pero si los archivos no son enormes (>50MB) estarías en línea con todos (MS incluido) al dejarlos en el directorio temporal. El espacio en disco es abundante.

Como csl publicó, el GetTempPath es el camino a seguir. Los usuarios que tienen poco espacio podrán ejecutar el liberador de espacio en disco y sus archivos (junto con los de todos los demás) se limpiarán.

Utilizo una solución más 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)) { }
            }
        }
    }
}

Cada vez que necesite usar un archivo temporal:

var tempFile = TemporaryFiles.UseNew();

Para asegurarse de que todos los archivos temporales se eliminen después de que la aplicación se cierre o se bloquee, ponga

TemporaryFiles.DeleteAllPreviouslyUsed();

Al inicio de la aplicación.

Puede iniciar un hilo al iniciar que eliminará los archivos que existen cuando "no deberían" para recuperarse de su bloqueo.

Si está creando una aplicación de Windows Forms, puede usar este código:

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        File.Delete("temp.data");
    }