Wie kann ich mit .NET eine temporäre Datei mit einer bestimmten Erweiterung erstellen?

Ich muss eine eindeutige temporäre Datei mit der Erweiterung .csv generieren.

Was ich gerade mache, ist

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

Dies garantiert jedoch nicht, dass meine CSV-Datei eindeutig ist.

Ich weiß, dass die Wahrscheinlichkeit, dass ich jemals eine Kollision habe, sehr gering ist (insbesondere wenn Sie bedenken, dass ich die .tmp-Dateien nicht lösche), aber dieser Code sieht für mich nicht gut aus.

Natürlich könnte ich manuell zufällige Dateinamen generieren, bis ich schließlich einen eindeutigen finde (was kein Problem sein sollte), aber ich bin gespannt, ob andere einen guten Weg gefunden haben, um mit diesem Problem umzugehen.

Garantiert (statistisch) eindeutig:

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

(Um aus dem Wiki-Artikel über die Wahrscheinlichkeit einer Kollision zu zitieren:

... das jährliche Risiko, von einem Meteoriten getroffen zu werden, wird auf eine Chance von 17 Milliarden geschätzt [19], was bedeutet, dass die Wahrscheinlichkeit etwa 0,00000000006 (6 × 10−11) beträgt, was der Wahrscheinlichkeit entspricht, einige zehn zu erzeugen Billionen von UUIDs in einem Jahr und mit einem Duplikat. Mit anderen Worten, erst nachdem in den nächsten 100 Jahren pro Sekunde 1 Milliarde UUIDs generiert wurden, würde die Wahrscheinlichkeit, nur ein Duplikat zu erstellen, bei etwa 50% liegen. Die Wahrscheinlichkeit eines Duplikats würde etwa 50% betragen, wenn jeder Mensch auf der Erde 600 Millionen UUIDs besitzt

EDIT: Bitte beachten Sie auch die Kommentare von JaredPar.

Probieren Sie diese Funktion aus ...

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

Es wird ein vollständiger Pfad mit der Erweiterung Ihrer Wahl zurückgegeben.

Es ist nicht garantiert, dass ein eindeutiger Dateiname erstellt wird, da diese Datei möglicherweise bereits von einer anderen Person erstellt wurde. Die Wahrscheinlichkeit, dass jemand die nächste von Ihrer App erstellte Anleitung errät und erstellt, ist jedoch sehr gering. Es ist ziemlich sicher anzunehmen, dass dies einzigartig sein wird.

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

Hinweis: Dies funktioniert wie Path.GetTempFileName. Eine leere Datei wird erstellt, um den Dateinamen zu reservieren. Bei Kollisionen, die von Path.GetRandomFileName () generiert werden, werden 10 Versuche ausgeführt.

Alternativ können Sie auch System.CodeDom.Compiler.TempFileCollection verwenden .

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

Hier habe ich eine txt-Erweiterung verwendet, aber Sie können angeben, was Sie wollen. Ich habe auch das Keep-Flag auf true gesetzt, damit die temporäre Datei nach der Verwendung erhalten bleibt. Leider erstellt TempFileCollection eine zufällige Datei pro Erweiterung. Wenn Sie mehr temporäre Dateien benötigen, können Sie mehrere Instanzen von TempFileCollection erstellen.

Warum nicht prüfen, ob die Datei existiert?

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

In der MSDN-Dokumentation zu GetTempFileName von C ++ wird Ihr Anliegen erläutert und beantwortet:

GetTempFileName kann nicht garantieren, dass der Dateiname eindeutig ist .

Es werden nur die unteren 16 Bits des Parameters uUnique verwendet. Dies begrenzt GetTempFileName auf maximal 65.535 eindeutige Dateinamen, wenn die Parameter lpPathName und lpPrefixString gleich bleiben.

Aufgrund des zum Generieren von Dateinamen verwendeten Algorithmus kann GetTempFileName beim Erstellen einer großen Anzahl von Dateien mit demselben Präfix eine schlechte Leistung erzielen. In solchen Fällen wird empfohlen, eindeutige Dateinamen basierend auf GUIDs zu erstellen .

Wie wäre es mit:

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

Es ist höchst unwahrscheinlich, dass der Computer zum gleichen Zeitpunkt dieselbe Guid generiert. Die einzige Schwäche, die ich hier sehe, ist die Auswirkung auf die Leistung, die DateTime.Now.Ticks hinzufügen wird.

Sie können auch Folgendes tun

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

und das funktioniert auch wie erwartet

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

Meiner Meinung nach werden die meisten Antworten hier als nicht optimal vorgeschlagen. Derjenige, der am nächsten kommt, ist der ursprüngliche, der ursprünglich von Brann vorgeschlagen wurde.

Ein temporärer Dateiname muss sein

• Einzigartig
• Konfliktfrei (noch nicht vorhanden)
• Atomic (Erstellung von Name & Datei im selben Vorgang)
• Schwer zu erraten

Aufgrund dieser Anforderungen ist es keine gute Idee, ein solches Tier selbst zu programmieren. Intelligente Leute, die E / A-Bibliotheken schreiben, sorgen sich um Dinge wie Sperren (falls erforderlich) usw. Daher sehe ich keine Notwendigkeit, System.IO.Path.GetTempFileName () neu zu schreiben.

Dies sollte, auch wenn es ungeschickt aussieht, den Job machen:

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

Dies könnte für Sie nützlich sein ... Es ist eine temporäre zu erstellen. Ordner und geben Sie es als Zeichenfolge in VB.NET zurück.

Einfach in C # umwandelbar:

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

Dies scheint für mich in Ordnung zu sein: Es prüft, ob Dateien vorhanden sind, und erstellt die Datei, um sicherzustellen, dass es sich um einen beschreibbaren Speicherort handelt. Sollte dies gut funktionieren, können Sie es ändern, um direkt den FileStream zurückzugeben (was normalerweise für eine temporäre Datei erforderlich ist):

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

Einfache Funktion in C #:

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

Ich habe die Antworten @Maxence und @Mitch Wheat gemischt, wobei ich die Semantik der GetTempFileName-Methode (der Dateiname ist der Name einer neu erstellten Datei) verwenden möchte, wobei die bevorzugte Erweiterung hinzugefügt wird.

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

Das mache ich:

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

Dies ist eine einfache, aber effektive Methode, um inkrementelle Dateinamen zu generieren. Es wird direkt in der aktuellen Version angezeigt (Sie können dies leicht auf eine andere Stelle verweisen) und nach Dateien mit der Basis YourApplicationName * .txt suchen (auch dies können Sie problemlos ändern). Es beginnt um 0000, sodass der erste Dateiname YourApplicationName0000.txt lautet. Wenn sich aus irgendeinem Grund Dateinamen mit Junk zwischen dem linken und dem rechten Teil befinden (dh keine Zahlen), werden diese Dateien aufgrund des Tryparse-Aufrufs ignoriert.

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

Aufgrund der Antworten, die ich aus dem Internet gefunden habe, komme ich wie folgt zu meinem Code:

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

Und als C # -Kochbuch von Jay Hilyard wies Stephen Teilhet auf die Verwendung einer temporären Datei in Ihrer Anwendung hin :

• Sie sollten eine temporäre Datei verwenden, wenn Sie Informationen vorübergehend speichern müssen, um sie später abzurufen.

• Das einzige, woran Sie denken müssen, ist, diese temporäre Datei zu löschen, bevor die Anwendung, die sie erstellt hat, beendet wird.

• Wenn es nicht gelöscht wird, bleibt es im temporären Verzeichnis des Benutzers, bis der Benutzer es manuell löscht.

Ich denke, Sie sollten dies versuchen:

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

Es generiert einen eindeutigen Dateinamen und erstellt eine Datei mit diesem Dateinamen an einem bestimmten Speicherort.