Criando um diretório temporário no Windows?

Qual é a melhor maneira de obter um nome de diretório temporário no Windows? Vejo que posso usar GetTempPathe GetTempFileNamecriar um arquivo temporário, mas há algum equivalente à função Linux / BSD mkdtemppara criar um diretório temporário?

Não, não há equivalente ao mkdtemp. A melhor opção é usar uma combinação de GetTempPath e GetRandomFileName .

Você precisaria de código semelhante a este:

public string GetTemporaryDirectory()
{
   string tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
   Directory.CreateDirectory(tempDirectory);
   return tempDirectory;
}

Eu cortei Path.GetTempFileName() para me fornecer um caminho de arquivo pseudo-aleatório válido no disco, excluo o arquivo e crio um diretório com o mesmo caminho de arquivo.

Isso evita a necessidade de verificar se o caminho do arquivo está disponível em um tempo ou loop, de acordo com o comentário de Chris sobre a resposta de Scott Dorman.

public string GetTemporaryDirectory()
{
  string tempFolder = Path.GetTempFileName();
  File.Delete(tempFolder);
  Directory.CreateDirectory(tempFolder);

  return tempFolder;
}

Se você realmente precisa de um nome aleatório criptograficamente seguro, convém adaptar a resposta de Scott para usar um while ou loop para continuar tentando criar um caminho no disco.

Eu gosto de usar GetTempPath (), uma função de criação de GUID como CoCreateGuid () e CreateDirectory ().

Um GUID é projetado para ter uma alta probabilidade de exclusividade, e também é altamente improvável que alguém crie manualmente um diretório com o mesmo formato de um GUID (e, se o fizer, o CreateDirectory () falhará indicando sua existência.)

@Chris. Eu também estava obcecado pelo risco remoto de um diretório temporário já existir. As discussões sobre aleatória e criptograficamente forte também não me satisfazem completamente.

Minha abordagem baseia-se no fato fundamental de que o sistema operacional não deve permitir 2 chamadas para criar um arquivo para que ambos tenham êxito. É um pouco surpreendente que os designers do .NET optem por ocultar a funcionalidade da API do Win32 para diretórios, o que facilita muito isso, pois retorna um erro quando você tenta criar um diretório pela segunda vez. Aqui está o que eu uso:

    [DllImport(@"kernel32.dll", EntryPoint = "CreateDirectory", SetLastError = true, CharSet = CharSet.Unicode)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool CreateDirectoryApi
        ([MarshalAs(UnmanagedType.LPTStr)] string lpPathName, IntPtr lpSecurityAttributes);

    /// <summary>
    /// Creates the directory if it does not exist.
    /// </summary>
    /// <param name="directoryPath">The directory path.</param>
    /// <returns>Returns false if directory already exists. Exceptions for any other errors</returns>
    /// <exception cref="System.ComponentModel.Win32Exception"></exception>
    internal static bool CreateDirectoryIfItDoesNotExist([NotNull] string directoryPath)
    {
        if (directoryPath == null) throw new ArgumentNullException("directoryPath");

        // First ensure parent exists, since the WIN Api does not
        CreateParentFolder(directoryPath);

        if (!CreateDirectoryApi(directoryPath, lpSecurityAttributes: IntPtr.Zero))
        {
            Win32Exception lastException = new Win32Exception();

            const int ERROR_ALREADY_EXISTS = 183;
            if (lastException.NativeErrorCode == ERROR_ALREADY_EXISTS) return false;

            throw new System.IO.IOException(
                "An exception occurred while creating directory'" + directoryPath + "'".NewLine() + lastException);
        }

        return true;
    }

Você decide se o "custo / risco" do código p / invocação não gerenciado vale a pena. A maioria diria que não, mas pelo menos agora você tem uma escolha.

CreateParentFolder () é deixado como um exercício para o aluno. Eu uso Directory.CreateDirectory (). Cuidado ao obter o pai de um diretório, pois ele é nulo na raiz.

Eu costumo usar isso:

    /// <summary>
    /// Creates the unique temporary directory.
    /// </summary>
    /// <returns>
    /// Directory path.
    /// </returns>
    public string CreateUniqueTempDirectory()
    {
        var uniqueTempDir = Path.GetFullPath(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
        Directory.CreateDirectory(uniqueTempDir);
        return uniqueTempDir;
    }

Se você deseja ter certeza absoluta de que esse nome de diretório não existe no caminho temporário, verifique se esse nome de diretório exclusivo existe e tente criar outro, se ele realmente existir.

Mas essa implementação baseada em GUID é suficiente. Não tenho experiência com nenhum problema neste caso. Alguns aplicativos MS também usam diretórios temporários baseados em GUID.

GetTempPath é a maneira correta de fazer isso; Não sei ao certo qual é a sua preocupação com esse método. Você pode usar o CreateDirectory para fazer isso.

Aqui está uma abordagem de força bruta para resolver o problema de colisão para nomes de diretório temporários. Não é uma abordagem infalível, mas reduz significativamente as chances de uma colisão no caminho da pasta.

É possível adicionar outras informações relacionadas ao processo ou à montagem ao nome do diretório para tornar a colisão ainda menos provável, embora tornar essas informações visíveis no nome do diretório temporário possa não ser desejável. Pode-se também misturar a ordem com a qual os campos relacionados ao tempo são combinados para tornar os nomes das pastas mais aleatórios. Pessoalmente, prefiro deixar dessa maneira simplesmente porque é mais fácil encontrá-las durante a depuração.

string randomlyGeneratedFolderNamePart = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());

string timeRelatedFolderNamePart = DateTime.Now.Year.ToString()
                                 + DateTime.Now.Month.ToString()
                                 + DateTime.Now.Day.ToString()
                                 + DateTime.Now.Hour.ToString()
                                 + DateTime.Now.Minute.ToString()
                                 + DateTime.Now.Second.ToString()
                                 + DateTime.Now.Millisecond.ToString();

string processRelatedFolderNamePart = System.Diagnostics.Process.GetCurrentProcess().Id.ToString();

string temporaryDirectoryName = Path.Combine( Path.GetTempPath()
                                            , timeRelatedFolderNamePart 
                                            + processRelatedFolderNamePart 
                                            + randomlyGeneratedFolderNamePart);

Como mencionado acima, Path.GetTempPath () é uma maneira de fazer isso. Você também pode chamar Environment.GetEnvironmentVariable ("TEMP") se o usuário tiver uma variável de ambiente TEMP configurada.

Se você planeja usar o diretório temp como um meio de persistência de dados no aplicativo, provavelmente deve usar o IsolatedStorage como um repositório para configuration / state / etc ...