Jak mogę utworzyć plik tymczasowy z określonym rozszerzeniem w .NET?

Muszę wygenerować unikalny plik tymczasowy z rozszerzeniem .csv.

To, co teraz robię, to

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

Nie gwarantuje to jednak, że mój plik .csv będzie unikalny.

Wiem, że szanse na kolizję są bardzo niskie (zwłaszcza jeśli uważasz, że nie usuwam plików .tmp), ale ten kod nie wygląda mi dobrze.

Oczywiście mogłem ręcznie generować losowe nazwy plików, aż w końcu znajdę unikalną (co nie powinno być problemem), ale jestem ciekawy, czy inni znaleźli dobry sposób na poradzenie sobie z tym problemem.

Gwarantujemy (statystycznie) unikalność:

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

(Cytat z artykułu wiki na temat prawdopodobieństwa kolizji:

... roczne ryzyko uderzenia meteorytu szacuje się na jedną szansę na 17 miliardów [19], co oznacza, że ​​prawdopodobieństwo wynosi około 0,00000000006 (6 × 10-11), co odpowiada prawdopodobieństwu wytworzenia kilkudziesięciu tryliony UUID w ciągu roku i posiadanie jednego duplikatu. Innymi słowy, tylko po wygenerowaniu 1 miliarda UUID co sekundę przez następne 100 lat prawdopodobieństwo utworzenia tylko jednego duplikatu wyniesie około 50%. Prawdopodobieństwo jednego duplikatu wynosiłoby około 50%, gdyby każda osoba na ziemi posiadała 600 milionów UUID

EDYCJA: Zobacz także komentarze JaredPara.

Wypróbuj tę funkcję ...

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

Zwróci pełną ścieżkę z wybranym rozszerzeniem.

Uwaga: nie ma gwarancji utworzenia unikalnej nazwy pliku, ponieważ ktoś inny mógł już technicznie utworzyć ten plik. Jednak szanse, że ktoś zgadnie kolejny przewodnik utworzony przez twoją aplikację i stworzy go, są bardzo niskie. Można założyć, że będzie to wyjątkowe.

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

Uwaga: działa to podobnie jak Path.GetTempFileName. Tworzony jest pusty plik, aby zarezerwować nazwę pliku. Wykonuje 10 prób w przypadku kolizji generowanych przez Path.GetRandomFileName ();

Możesz także alternatywnie użyć 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");

Tutaj użyłem rozszerzenia txt, ale możesz określić, co chcesz. Ustawiłem również flagę keep na wartość true, aby plik tymczasowy był zachowywany po użyciu. Niestety TempFileCollection tworzy jeden losowy plik na rozszerzenie. Jeśli potrzebujesz więcej plików tymczasowych, możesz utworzyć wiele instancji TempFileCollection.

Dlaczego nie sprawdzić, czy plik istnieje?

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

Dokumentacja MSDN dla GetTempFileName w C ++ omawia twoje obawy i odpowiada na nie:

GetTempFileName nie jest w stanie zagwarantować, że nazwa pliku jest unikalna .

Wykorzystywane są tylko dolne 16 bitów niepowtarzalnego parametru. Ogranicza to GetTempFileName do maksymalnie 65 535 unikalnych nazw plików, jeśli parametry lpPathName i lpPrefixString pozostają takie same.

Ze względu na algorytm używany do generowania nazw plików GetTempFileName może słabo działać podczas tworzenia dużej liczby plików z tym samym prefiksem. W takich przypadkach zaleca się tworzenie unikalnych nazw plików na podstawie identyfikatorów GUID .

Co powiesz na:

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

Jest wysoce nieprawdopodobne, aby komputer wygenerował tego samego Guida w tym samym momencie. Jedyną słabością, którą tu widzę, jest wpływ DateTime.Now.Ticks na wydajność.

Możesz także wykonać następujące czynności

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

i to również działa zgodnie z oczekiwaniami

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

Moim zdaniem większość odpowiedzi zaproponowano tutaj jako nieoptymalne. Najbliżej jest oryginalny zaproponowany początkowo przez Branna.

Nazwa pliku tymczasowego musi być

• Wyjątkowy
• Bez konfliktów (jeszcze nie istnieje)
• Atomic (tworzenie nazwy i pliku w tej samej operacji)
• Trudno zgadnąć

Z powodu tych wymagań nie jest cholernym pomysłem samodzielne zaprogramowanie takiej bestii. Inteligentni ludzie piszący biblioteki IO martwią się takimi rzeczami jak blokowanie (w razie potrzeby) itp. Dlatego nie widzę potrzeby przepisywania System.IO.Path.GetTempFileName ().

To, nawet jeśli wygląda na niezdarne, powinno wykonać zadanie:

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

Może ci się to przydać ... Aby stworzyć temp. folder i zwróć jako ciąg w VB.NET.

Łatwo konwertowalny do 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

Wydaje mi się, że to działa dobrze: sprawdza obecność pliku i tworzy plik, aby upewnić się, że jest to zapisywalna lokalizacja. Powinien działać poprawnie, możesz go zmienić, aby zwracał bezpośrednio FileStream (co zwykle jest potrzebne do pliku tymczasowego):

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

Łatwa funkcja w C #:

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

Mam mieszane @Maxence i @Mitch Pszenica odpowiedzi pamiętając chcę semantyczne metody GetTempFileName (nazwa pliku to nazwa nowego pliku utworzonego) dodanie rozszerzenia preferowany.

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

Oto co robię:

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

Jest to prosty, ale skuteczny sposób generowania przyrostowych nazw plików. Będzie szukał bezpośrednio w bieżącym (możesz łatwo wskazać to gdzie indziej) i szukał plików za pomocą podstawowej YourApplicationName * .txt (ponownie możesz to łatwo zmienić). Rozpocznie się o 0000, tak aby pierwsza nazwa pliku to YourApplicationName0000.txt. jeśli z jakiegoś powodu istnieją nazwy plików ze śmieciami (czyli nie liczbami) między lewą a prawą częścią, pliki te zostaną zignorowane na podstawie wywołania 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;
    }

Na podstawie odpowiedzi, które znalazłem w Internecie, dochodzę do mojego kodu w następujący sposób:

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

Jak wskazał Jay Hilyard w książce kucharskiej C #, Stephen Teilhet wskazał na użycie pliku tymczasowego w aplikacji :

• powinieneś użyć pliku tymczasowego, ilekroć potrzebujesz tymczasowo przechowywać informacje do późniejszego pobrania.

• Jedyną rzeczą, o której musisz pamiętać, jest usunięcie tego pliku tymczasowego przed zakończeniem aplikacji, która go utworzyła.

• Jeśli nie zostanie usunięty, pozostanie w katalogu tymczasowym użytkownika, dopóki użytkownik nie usunie go ręcznie.

Myślę, że powinieneś spróbować:

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

Generuje unikalną nazwę pliku i tworzy plik o tej nazwie w określonej lokalizacji.