Como posso criar um arquivo temporário com uma extensão específica no .NET?

Preciso gerar um arquivo temporário exclusivo com uma extensão .csv.

O que eu faço agora é

string filename = System.IO.Path.GetTempFileName().Replace(".tmp", ".csv");

No entanto, isso não garante que meu arquivo .csv seja exclusivo.

Sei que as chances de colisão são muito baixas (especialmente se você considerar que eu não excluo os arquivos .tmp), mas esse código não parece bom para mim.

É claro que eu poderia gerar manualmente nomes de arquivos aleatórios até encontrar um único (o que não deve ser um problema), mas estou curioso para saber se outras pessoas encontraram uma boa maneira de lidar com esse problema.

Garantido para ser (estatisticamente) único:

string fileName = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".csv"; 

(Para citar o artigo da wiki sobre a probabilidade de uma colisão:

... o risco anual de alguém de ser atingido por um meteorito é estimado em uma chance em 17 bilhões [19], o que significa que a probabilidade é de 0,00000000006 (6 × 10-11), equivalente às chances de criar algumas dezenas de trilhões de UUIDs em um ano e com uma duplicata. Em outras palavras, somente após gerar 1 bilhão de UUIDs a cada segundo nos próximos 100 anos, a probabilidade de criar apenas uma duplicata seria de cerca de 50%. A probabilidade de uma duplicata seria de cerca de 50% se todas as pessoas na Terra possuírem 600 milhões de UUIDs

EDIT: Por favor, veja também os comentários de JaredPar.

Tente esta função ...

public static string GetTempFilePathWithExtension(string extension) {
  var path = Path.GetTempPath();
  var fileName = Guid.NewGuid().ToString() + extension;
  return Path.Combine(path, fileName);
}

Ele retornará um caminho completo com a extensão de sua escolha.

Observe que não é garantido que você produza um nome de arquivo exclusivo, pois outra pessoa já pode ter criado esse arquivo tecnicamente. No entanto, as chances de alguém adivinhar o próximo guia produzido pelo seu aplicativo e criá-lo são muito muito baixas. É bastante seguro assumir que isso será único.

public static string GetTempFileName(string extension)
{
  int attempt = 0;
  while (true)
  {
    string fileName = Path.GetRandomFileName();
    fileName = Path.ChangeExtension(fileName, extension);
    fileName = Path.Combine(Path.GetTempPath(), fileName);

    try
    {
      using (new FileStream(fileName, FileMode.CreateNew)) { }
      return fileName;
    }
    catch (IOException ex)
    {
      if (++attempt == 10)
        throw new IOException("No unique temporary file name is available.", ex);
    }
  }
}

Nota: isso funciona como Path.GetTempFileName. Um arquivo vazio é criado para reservar o nome do arquivo. Faz 10 tentativas, no caso de colisões geradas por Path.GetRandomFileName ();

Como alternativa, você também pode usar System.CodeDom.Compiler.TempFileCollection .

string tempDirectory = @"c:\\temp";
TempFileCollection coll = new TempFileCollection(tempDirectory, true);
string filename = coll.AddExtension("txt", true);
File.WriteAllText(Path.Combine(tempDirectory,filename),"Hello World");

Aqui eu usei uma extensão txt, mas você pode especificar o que quiser. Também defino o sinalizador keep como true para que o arquivo temporário seja mantido após o uso. Infelizmente, TempFileCollection cria um arquivo aleatório por extensão. Se você precisar de mais arquivos temporários, poderá criar várias instâncias do TempFileCollection.

Por que não verificar se o arquivo existe?

string fileName;
do
{
    fileName = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".csv";
} while (System.IO.File.Exists(fileName));

A documentação do MSDN para GetTempFileName do C ++ discute sua preocupação e a responde:

GetTempFileName não pode garantir que o nome do arquivo seja exclusivo .

Somente os 16 bits inferiores do parâmetro uUnique são usados. Isso limita GetTempFileName a um máximo de 65.535 nomes de arquivos exclusivos se os parâmetros lpPathName e lpPrefixString permanecerem os mesmos.

Devido ao algoritmo usado para gerar nomes de arquivos, GetTempFileName pode ter um desempenho ruim ao criar um grande número de arquivos com o mesmo prefixo. Nesses casos, é recomendável que você construa nomes de arquivos exclusivos com base nos GUIDs .

E se:

Path.Combine(Path.GetTempPath(), DateTime.Now.Ticks.ToString() + "_" + Guid.NewGuid().ToString() + ".csv")

É altamente improvável que o computador gere o mesmo Guid no mesmo instante de tempo. A única fraqueza que vejo aqui é o impacto no desempenho que o DateTime.Now.Ticks adicionará.

Você também pode fazer o seguinte

string filename = Path.ChangeExtension(Path.GetTempFileName(), ".csv");

e isso também funciona como esperado

string filename = Path.ChangeExtension(Path.GetTempPath() + Guid.NewGuid().ToString(), ".csv");

Na minha opinião, a maioria das respostas propostas aqui é subótima. O que mais se aproxima é o original proposto inicialmente por Brann.

Um nome de arquivo temporário deve ser

• Único
• Sem conflitos (ainda não existe)
• Atômico (criação de nome e arquivo na mesma operação)
• Difícil de adivinhar

Devido a esses requisitos, não é uma boa idéia programar um animal desses por conta própria. Pessoas inteligentes que escrevem bibliotecas de E / S se preocupam com coisas como bloqueio (se necessário) etc. Portanto, não vejo necessidade de reescrever System.IO.Path.GetTempFileName ().

Isso, mesmo que pareça desajeitado, deve fazer o trabalho:

//Note that this already *creates* the file
string filename1 = System.IO.Path.GetTempFileName()
// Rename and move
filename = filename.Replace(".tmp", ".csv");
File.Move(filename1 , filename);

Isso pode ser útil para você ... É criar uma temperatura. pasta e retorne-a como uma string no VB.NET.

Facilmente conversível em C #:

Public Function GetTempDirectory() As String
    Dim mpath As String
    Do
        mpath = System.IO.Path.Combine(System.IO.Path.GetTempPath, System.IO.Path.GetRandomFileName)
    Loop While System.IO.Directory.Exists(mpath) Or System.IO.File.Exists(mpath)
    System.IO.Directory.CreateDirectory(mpath)
    Return mpath
End Function

Isso parece funcionar bem para mim: verifica a existência do arquivo e cria o arquivo para garantir que seja um local gravável. Deve funcionar bem, você pode alterá-lo para retornar diretamente o FileStream (que normalmente é o que você precisa para um arquivo temporário):

private string GetTempFile(string fileExtension)
{
  string temp = System.IO.Path.GetTempPath();
  string res = string.Empty;
  while (true) {
    res = string.Format("{0}.{1}", Guid.NewGuid().ToString(), fileExtension);
    res = System.IO.Path.Combine(temp, res);
    if (!System.IO.File.Exists(res)) {
      try {
        System.IO.FileStream s = System.IO.File.Create(res);
        s.Close();
        break;
      }
      catch (Exception) {

      }
    }
  }
  return res;
} // GetTempFile

Função Fácil em C #:

public static string GetTempFileName(string extension = "csv")
{
    return Path.ChangeExtension(Path.GetTempFileName(), extension);
}

Com base nas respostas que encontrei na internet, chego ao meu código da seguinte maneira:

public static string GetTemporaryFileName()
{       
    string tempFilePath = Path.Combine(Path.GetTempPath(), "SnapshotTemp");
    Directory.Delete(tempFilePath, true);
    Directory.CreateDirectory(tempFilePath);
    return Path.Combine(tempFilePath, DateTime.Now.ToString("MMddHHmm") + "-" + Guid.NewGuid().ToString() + ".png");
}

E, como livro de receitas do C # de Jay Hilyard, Stephen Teilhet apontou em Usando um arquivo temporário no seu aplicativo :

• você deve usar um arquivo temporário sempre que precisar armazenar informações temporariamente para recuperação posterior.

• A única coisa que você deve se lembrar é excluir esse arquivo temporário antes que o aplicativo que o criou seja finalizado.

• Se não for excluído, ele permanecerá no diretório temporário do usuário até que o usuário o exclua manualmente.

Eu misturei @Maxence e @ Mitch Trigo respostas tendo em mente Eu quero a semântica do método GetTempFileName (o nome do arquivo é o nome de um novo arquivo criado) adicionando a extensão preferido.

string GetNewTempFile(string extension)
{
    if (!extension.StartWith(".")) extension="." + extension;
    string fileName;
    bool bCollisions = false;
    do {
        fileName = Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString() + extension);
        try
        {
            using (new FileStream(fileName, FileMode.CreateNew)) { }
            bCollisions = false;
        }
        catch (IOException)
        {
            bCollisions = true;
        }
    }
    while (bCollisions);
    return fileName;
}

Isto é o que estou fazendo:

string tStamp = String.Format ("{0: aaaaMMdd.HHmmss}", DateTime.Now);
string ProcID = Process.GetCurrentProcess (). Id.ToString ();
string tmpFolder = System.IO.Path.GetTempPath ();
string outFile = tmpFolder + ProcID + "_" + tStamp + ".txt";

Essa é uma maneira simples, mas eficaz, de gerar nomes de arquivos incrementais. Ele procurará a corrente diretamente (você pode facilmente apontar isso para outro lugar) e procurará por arquivos com o YourApplicationName * .txt básico (novamente, você pode alterar isso facilmente). Ele começará às 0000, para que o primeiro nome do arquivo seja YourApplicationName0000.txt. se, por algum motivo, houver nomes de arquivos com lixo eletrônico (significando não números) as partes esquerda e direita, esses arquivos serão ignorados em virtude da chamada tryparse.

    public static string CreateNewOutPutFile()
    {
        const string RemoveLeft = "YourApplicationName";
        const string RemoveRight = ".txt";
        const string searchString = RemoveLeft + "*" + RemoveRight;
        const string numberSpecifier = "0000";

        int maxTempNdx = -1;

        string fileName;
        string [] Files = Directory.GetFiles(Directory.GetCurrentDirectory(), searchString);
        foreach( string file in Files)
        {
            fileName = Path.GetFileName(file);
            string stripped = fileName.Remove(fileName.Length - RemoveRight.Length, RemoveRight.Length).Remove(0, RemoveLeft.Length);
            if( int.TryParse(stripped,out int current) )
            {
                if (current > maxTempNdx)
                    maxTempNdx = current;
            }
        }
        maxTempNdx++;
        fileName = RemoveLeft + maxTempNdx.ToString(numberSpecifier) + RemoveRight;
        File.CreateText(fileName); // optional
        return fileName;
    }

Eu acho que você deveria tentar o seguinte:

string path = Path.GetRandomFileName();
path = Path.Combine(@"c:\temp", path);
path = Path.ChangeExtension(path, ".tmp");
File.Create(path);

Ele gera um nome de arquivo exclusivo e cria um arquivo com esse nome em um local especificado.