Come posso creare un file temporaneo con un'estensione specifica con .NET?

Devo generare un file temporaneo univoco con estensione .csv.

Quello che faccio adesso è

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

Tuttavia, ciò non garantisce che il mio file .csv sarà univoco.

So che le probabilità che io abbia mai avuto una collisione sono molto basse (specialmente se si considera che non elimino i file .tmp), ma questo codice non mi sembra buono.

Ovviamente potrei generare manualmente nomi di file casuali fino a quando non ne trovo uno unico (che non dovrebbe essere un problema), ma sono curioso di sapere se altri hanno trovato un modo carino per affrontare questo problema.

Garantito per essere (statisticamente) unico:

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

(Per citare l'articolo della wiki sulla probabilità di una collisione:

... si stima che il rischio annuale di essere colpiti da un meteorite sia una possibilità su 17 miliardi [19], il che significa che la probabilità è di circa 0,00000000006 (6 × 10−11), equivalente alla probabilità di creare alcune decine di trilioni di UUID in un anno e con un duplicato. In altre parole, solo dopo aver generato 1 miliardo di UUID al secondo per i prossimi 100 anni, la probabilità di creare un solo duplicato sarebbe di circa il 50%. La probabilità di un duplicato sarebbe di circa il 50% se ogni persona sulla terra possiede 600 milioni di UUID

EDIT: Vedi anche i commenti di JaredPar.

Prova questa funzione ...

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

Restituirà un percorso completo con l'estensione di tua scelta.

Nota, non è garantito produrre un nome file univoco poiché qualcun altro potrebbe aver tecnicamente già creato quel file. Tuttavia, le probabilità che qualcuno indovini la guida successiva prodotta dalla tua app e la crei è molto bassa. È abbastanza sicuro supporre che questo sarà unico.

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: funziona come Path.GetTempFileName. Viene creato un file vuoto per riservare il nome del file. Effettua 10 tentativi, in caso di collisioni generate da Path.GetRandomFileName ();

In alternativa, puoi anche utilizzare 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");

Qui ho usato un'estensione txt ma puoi specificare quello che vuoi. Ho anche impostato il flag keep su true in modo che il file temporaneo sia conservato dopo l'uso. Sfortunatamente, TempFileCollection crea un file casuale per estensione. Se hai bisogno di più file temporanei, puoi creare più istanze di TempFileCollection.

Perché non controllare se il file esiste?

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

La documentazione MSDN per GetTempFileName di C ++ discute le tue preoccupazioni e le risponde:

GetTempFileName non è in grado di garantire che il nome del file sia univoco .

Vengono utilizzati solo i 16 bit inferiori del parametro uUnique. Ciò limita GetTempFileName a un massimo di 65.535 nomi di file univoci se i parametri lpPathName e lpPrefixString rimangono invariati.

A causa dell'algoritmo utilizzato per generare i nomi dei file, GetTempFileName può funzionare male quando si crea un numero elevato di file con lo stesso prefisso. In questi casi, si consiglia di costruire nomi di file univoci basati su GUID .

Che ne dite di:

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

È altamente improbabile che il computer generi lo stesso Guid nello stesso istante di tempo. L'unico punto debole che vedo qui è l'impatto sulle prestazioni che DateTime.Now.Ticks aggiungerà.

Puoi anche fare quanto segue

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

e questo funziona anche come previsto

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

A mio avviso, la maggior parte delle risposte proposte qui non è ottimale. Quello che si avvicina di più è quello originale proposto inizialmente da Brann.

Un nome file temporaneo deve essere

• Unico
• Senza conflitti (non esiste già)
• Atomic (creazione di nome e file nella stessa operazione)
• Difficile da indovinare

A causa di questi requisiti, non è una buona idea programmare una tale bestia da soli. Le persone intelligenti che scrivono librerie IO si preoccupano di cose come il blocco (se necessario) ecc. Pertanto, non vedo la necessità di riscrivere System.IO.Path.GetTempFileName ().

Questo, anche se sembra goffo, dovrebbe fare il lavoro:

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

Questo potrebbe essere utile per te ... È per creare una temperatura. cartella e restituirlo come stringa in VB.NET.

Facilmente convertibile in 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

Questo sembra funzionare bene per me: controlla l'esistenza del file e crea il file per essere sicuro che sia un percorso scrivibile. Dovrebbe funzionare bene, puoi cambiarlo per restituire direttamente FileStream (che normalmente è quello che ti serve per un file temporaneo):

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

Funzione facile in C #:

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

Sulla base delle risposte che ho trovato da Internet, arrivo al mio codice come segue:

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 come Cookbook C # di Jay Hilyard, Stephen Teilhet ha sottolineato nell'uso di un file temporaneo nell'applicazione :

• è necessario utilizzare un file temporaneo ogni volta che è necessario archiviare temporaneamente le informazioni per il successivo recupero.

• L'unica cosa che devi ricordare è eliminare questo file temporaneo prima che l'applicazione che lo ha creato sia terminata.

• Se non viene eliminato, rimarrà nella directory temporanea dell'utente fino a quando l'utente non lo elimina manualmente.

Ho mescolato le risposte di @Maxence e @Mitch Wheat tenendo presente che desidero la semantica del metodo GetTempFileName (fileName è il nome di un nuovo file creato) che aggiunge l'estensione preferita.

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

Questo è quello che sto facendo:

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

Questo è un modo semplice ma efficace per generare nomi di file incrementali. Guarderà direttamente la corrente (puoi facilmente indicarla da qualche altra parte) e cercherà i file con la tua base YourApplicationName * .txt (di nuovo puoi facilmente cambiarla). Inizierà a 0000 in modo che il primo nome file sia YourApplicationName0000.txt. se per qualche motivo ci sono nomi di file con posta indesiderata tra (che significa non numeri) le parti sinistra e destra, tali file saranno ignorati in virtù della chiamata 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;
    }

Penso che dovresti provare questo:

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

Genera un nome file univoco e crea un file con quel nome file in una posizione specificata.