Comment puis-je créer un fichier temporaire avec une extension spécifique avec .NET?

J'ai besoin de générer un fichier temporaire unique avec une extension .csv.

Ce que je fais en ce moment c'est

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

Cependant, cela ne garantit pas que mon fichier .csv sera unique.

Je sais que les chances d'avoir une collision sont très faibles (surtout si vous considérez que je ne supprime pas les fichiers .tmp), mais ce code ne me semble pas bon.

Bien sûr, je pouvais générer manuellement des noms de fichiers aléatoires jusqu'à ce que j'en trouve finalement un unique (ce qui ne devrait pas être un problème), mais je suis curieux de savoir si d'autres ont trouvé une bonne façon de résoudre ce problème.

Garanti (statistiquement) unique:

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

(Pour citer un article du wiki sur la probabilité d'une collision:

... le risque annuel d'être touché par une météorite est estimé à une chance sur 17 milliards [19], ce qui signifie que la probabilité est d'environ 0,0000000000006 (6 × 10−11), ce qui équivaut à la probabilité de créer quelques dizaines de mille milliards d'UUID en un an et en avoir un double. En d'autres termes, seulement après avoir généré 1 milliard d'UUID par seconde pendant les 100 prochaines années, la probabilité de créer un seul doublon serait d'environ 50%. La probabilité d'un double serait d'environ 50% si chaque personne sur terre possède 600 millions d'UUID

EDIT: Veuillez également consulter les commentaires de JaredPar.

Essayez cette fonction ...

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

Il renverra un chemin complet avec l'extension de votre choix.

Remarque, il n'est pas garanti de produire un nom de fichier unique car quelqu'un d'autre aurait pu techniquement déjà créé ce fichier. Cependant, les chances que quelqu'un devine le prochain guide produit par votre application et le crée sont très très faibles. Il est assez sûr de supposer que ce sera unique.

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

Remarque: cela fonctionne comme Path.GetTempFileName. Un fichier vide est créé pour réserver le nom du fichier. Il fait 10 tentatives, en cas de collisions générées par Path.GetRandomFileName ();

Vous pouvez également utiliser 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");

Ici, j'ai utilisé une extension txt mais vous pouvez spécifier ce que vous voulez. J'ai également défini l'indicateur keep sur true afin que le fichier temporaire soit conservé après utilisation. Malheureusement, TempFileCollection crée un fichier aléatoire par extension. Si vous avez besoin de plus de fichiers temporaires, vous pouvez créer plusieurs instances de TempFileCollection.

Pourquoi ne pas vérifier si le fichier existe?

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

La documentation MSDN pour GetTempFileName de C ++ explique votre problème et y répond:

GetTempFileName ne peut pas garantir que le nom de fichier est unique .

Seuls les 16 bits inférieurs du paramètre uUnique sont utilisés. Cela limite GetTempFileName à un maximum de 65 535 noms de fichiers uniques si les paramètres lpPathName et lpPrefixString restent les mêmes.

En raison de l'algorithme utilisé pour générer les noms de fichiers, GetTempFileName peut mal fonctionner lors de la création d'un grand nombre de fichiers avec le même préfixe. Dans de tels cas, il est recommandé de créer des noms de fichiers uniques en fonction des GUID .

Que diriez-vous:

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

Il est hautement improbable que l'ordinateur génère le même Guid au même instant. La seule faiblesse que je vois ici est l'impact sur les performances que DateTime.Now.Ticks ajoutera.

Vous pouvez également effectuer les opérations suivantes

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

et cela fonctionne aussi comme prévu

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

À mon avis, la plupart des réponses proposées ici ne sont pas optimales. Celui qui s'en rapproche le plus est celui proposé initialement par Brann.

Un nom de fichier temporaire doit être

• Unique
• Sans conflit (n'existe pas déjà)
• Atomic (Création du nom et du fichier dans la même opération)
• Difficile à deviner

En raison de ces exigences, ce n'est pas une mauvaise idée de programmer une telle bête par vous-même. Les personnes intelligentes écrivant des bibliothèques d'E / S s'inquiètent de choses comme le verrouillage (si nécessaire), etc. Par conséquent, je ne vois pas la nécessité de réécrire System.IO.Path.GetTempFileName ().

Cela, même s'il semble maladroit, devrait faire l'affaire:

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

Cela pourrait être pratique pour vous ... C'est pour créer un temp. dossier et le renvoyer sous forme de chaîne dans VB.NET.

Facilement convertible en 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

Cela semble bien fonctionner pour moi: il vérifie l'existence du fichier et crée le fichier pour être sûr qu'il s'agit d'un emplacement accessible en écriture. Devrait fonctionner correctement, vous pouvez le changer pour retourner directement le FileStream (qui est normalement ce dont vous avez besoin pour un fichier temporaire):

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

Fonction facile en C #:

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

Sur la base des réponses que j'ai trouvées sur Internet, j'arrive à mon code comme suit:

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

Et comme le livre de recettes C # par Jay Hilyard, Stephen Teilhet a souligné dans Utilisation d'un fichier temporaire dans votre application :

• vous devez utiliser un fichier temporaire chaque fois que vous avez besoin de stocker des informations temporairement pour une récupération ultérieure.

• La seule chose dont vous devez vous souvenir est de supprimer ce fichier temporaire avant la fermeture de l'application qui l'a créé.

• S'il n'est pas supprimé, il restera dans le répertoire temporaire de l'utilisateur jusqu'à ce que l'utilisateur le supprime manuellement.

J'ai mélangé les réponses @Maxence et @Mitch Wheat en gardant à l'esprit que je veux la sémantique de la méthode GetTempFileName (le fileName est le nom d'un nouveau fichier créé) en ajoutant l'extension préférée.

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

Voici ce que je fais:

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

Il s'agit d'un moyen simple mais efficace de générer des noms de fichiers incrémentiels. Il cherchera directement dans le courant (vous pouvez facilement le signaler ailleurs) et recherchera des fichiers avec la base YourApplicationName * .txt (encore une fois, vous pouvez facilement changer cela). Il commencera à 0000 afin que le premier nom de fichier soit YourApplicationName0000.txt. si pour une raison quelconque, il y a des noms de fichiers avec des ordures entre (ce qui ne signifie pas des nombres) les parties gauche et droite, ces fichiers seront ignorés en raison de l'appel 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;
    }

Je pense que vous devriez essayer ceci:

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

Il génère un nom de fichier unique et crée un fichier avec ce nom de fichier à un emplacement spécifié.