arquivos temporários em .Net

Question

Eu preciso criar alguns bitmaps e guardá-las para o sistema de arquivos. Por alguma razão o sistema MScharting quer de arquivos de fundo suprimentos como caminhos em forma de string.

Eu estou criando dinamicamente a imagem de fundo, embora apenas algumas vezes.

Qual é a melhor maneira de criar esses arquivos e, em seguida, limpá-los?

Answer 1

Sua melhor aposta é ter um TemporaryFileManager que implementa IDisposable; você perguntar isso para arquivos temporários, que se auto-gera e varas em um algum lugar diretório temporário, em seguida, todos eles são apagados quando o TemporaryFileManager fica disposto, por você ou o finalizador (se você implementou o padrão descartável corretamente)

Answer 2

Aqui está como você pode obter o caminho completo e nome de um arquivo temporário file:

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

Criar o arquivo usando este nome de arquivo e caminho e quando você está feito excluí-lo.

Answer 3

Em meus projetos, eu tenho uma classe auxiliar chamada tempfile. Tem vários métodos estáticos que eu uso para escrever uma corrente (ou um array de bytes, se necessário) para um arquivo temporário. Aqui está um exemplo simplificado de tal método a:

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

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

   return FileName;
}

Então, eu tenho um outro método que aceita um caminho de arquivo para exclusão depois que é um membro da minha classe 'analisar', embora você poderia colocá-lo em seu próprio classe auxiliar estática:

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

   return path;
}

Finalmente, faça o seguinte:

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

Esta é a melhor maneira que eu vim acima com para contornar a falta de recursos de manipulação de fluxo de uma API.

Answer 4

Eu uso essa solução:

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 você precisa usar o arquivo temporário:

var tempFile = TemporaryFiles.UseNew();

Para ter certeza de todos os arquivos temporários são apagadas após fecha aplicação ou falha colocar

TemporaryFiles.DeleteAllPreviouslyUsed();

no início da aplicação.