Créer un répertoire temporaire sous Windows?

Quelle est la meilleure façon d'obtenir un nom de répertoire temporaire dans Windows? Je vois que je peux utiliser GetTempPathet GetTempFileNamecréer un fichier temporaire, mais existe-t-il un équivalent à la fonction Linux / BSD mkdtemppour créer un répertoire temporaire?

Non, il n'y a pas d'équivalent à mkdtemp. La meilleure option consiste à utiliser une combinaison de GetTempPath et GetRandomFileName .

Vous auriez besoin d'un code similaire à celui-ci:

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

Je pirate Path.GetTempFileName()pour me donner un chemin de fichier pseudo-aléatoire valide sur le disque, puis supprime le fichier et crée un répertoire avec le même chemin de fichier.

Cela évite d'avoir à vérifier si le chemin du fichier est disponible dans un moment ou une boucle, selon le commentaire de Chris sur la réponse de Scott Dorman.

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

  return tempFolder;
}

Si vous avez vraiment besoin d'un nom aléatoire sécurisé cryptographiquement, vous pouvez adapter la réponse de Scott pour utiliser un moment ou faire une boucle pour continuer à essayer de créer un chemin sur le disque.

J'aime utiliser GetTempPath (), une fonction de création de GUID comme CoCreateGuid () et CreateDirectory ().

Un GUID est conçu pour avoir une forte probabilité d'unicité, et il est également hautement improbable que quelqu'un crée manuellement un répertoire avec la même forme qu'un GUID (et s'ils le font, CreateDirectory () échouera en indiquant son existence.)

@Chris. J'étais aussi obsédé par le risque distant qu'un répertoire temporaire puisse déjà exister. Les discussions sur le hasard et la cryptographie forte ne me satisfont pas complètement non plus.

Mon approche repose sur le fait fondamental que l'O / S ne doit pas permettre à 2 appels de créer un fichier pour que les deux réussissent. Il est un peu surprenant que les concepteurs .NET aient choisi de masquer la fonctionnalité de l'API Win32 pour les répertoires, ce qui rend cela beaucoup plus facile, car cela renvoie une erreur lorsque vous essayez de créer un répertoire pour la deuxième fois. Voici ce que j'utilise:

    [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;
    }

Vous décidez si le «coût / risque» du code p / invoke non géré en vaut la peine. La plupart diraient que ce n'est pas le cas, mais au moins, vous avez maintenant le choix.

CreateParentFolder () est laissé comme exercice à l'étudiant. J'utilise Directory.CreateDirectory (). Faites attention à obtenir le parent d'un répertoire, car il est nul à la racine.

J'utilise habituellement ceci:

    /// <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;
    }

Si vous voulez être absolument sûr que ce nom de répertoire n'existe pas dans le chemin temporaire, vous devez vérifier si ce nom de répertoire unique existe et essayer d'en créer un autre s'il existe réellement.

Mais cette implémentation basée sur GUID est suffisante. Je n'ai aucune expérience avec aucun problème dans ce cas. Certaines applications MS utilisent également des répertoires temporaires basés sur GUID.

GetTempPath est la bonne façon de le faire; Je ne sais pas quelle est votre préoccupation concernant cette méthode. Vous pouvez ensuite utiliser CreateDirectory pour le créer.

Voici une approche un peu plus brutale pour résoudre le problème de collision des noms de répertoires temporaires. Ce n'est pas une approche infaillible, mais elle réduit considérablement les risques de collision de chemin de dossier.

On pourrait éventuellement ajouter d'autres informations relatives au processus ou à l'assemblage au nom du répertoire pour rendre la collision encore moins probable, bien que rendre ces informations visibles sur le nom du répertoire temporaire ne soit pas souhaitable. On pourrait également mélanger l'ordre dans lequel les champs liés au temps sont combinés pour rendre les noms de dossier plus aléatoires. Personnellement, je préfère le laisser ainsi simplement parce qu'il m'est plus facile de tous les trouver pendant le débogage.

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);

Comme mentionné ci-dessus, Path.GetTempPath () est une façon de le faire. Vous pouvez également appeler Environment.GetEnvironmentVariable ("TEMP") si l'utilisateur a configuré une variable d'environnement TEMP.

Si vous prévoyez d'utiliser le répertoire temporaire comme moyen de persister des données dans l'application, vous devriez probablement envisager d'utiliser IsolatedStorage comme référentiel pour configuration / state / etc ...