Verhalten bei temporären Windows-Dateien - Werden sie vom System gelöscht?

Mithilfe der .net framework Sie haben die Möglichkeit, temporäre Dateien erstellen, mit

Path.GetTempFileName();

Die MSDN sagt uns nicht, was passiert, um die temporären Dateien. Ich erinnere mich, irgendwo gelesen zu haben, dass Sie gelöscht werden, indem das OS, wenn es bekommt einen Neustart. Ist das wahr?

Wenn die Dateien nicht gelöscht vom OS, warum sind Sie aufgerufen, vorübergehend? Sie sind normale Dateien in einem normalen Verzeichnis.

InformationsquelleAutor der Frage Bogdan Gavril | 2008-11-27

  1. 41

    Die kurze Antwort: Sie werden nicht gelöscht.

    Die lange Antwort:
    Die verwalteten Weg.GetTempFileName() Methode ruft die native Win32API GetTempFileName() Methode, wie diese: 

    //actual .NET 2.0 decompiled code 
//.NET Reflector rocks for looking at plumbing
public static string GetTempFileName()
{
    string tempPath = GetTempPath();
    new FileIOPermission(FileIOPermissionAccess.Write, tempPath).Demand();
    StringBuilder tmpFileName = new StringBuilder(260);
    if (Win32Native.GetTempFileName(tempPath, "tmp", 0, tmpFileName) == 0)
    {
        __Error.WinIOError();
    }
    return tmpFileName.ToString();
}

    In der Dokumentation für die native Methode besagt:

    Verhalten bei temporären Windows-Dateien - Werden sie vom System gelöscht? Temporären Dateien, deren Namen erstellt wurden, von dieser Funktion nicht automatisch gelöscht. Um diese Dateien zu löschen rufen DeleteFile.

    Ich fand einen großen Artikel genannt "Diese lästigen temp-Dateien" (Archiv Okt. 2007), die beginnt von den Grundlagen und berührt einige der weniger offensichtlichen Probleme der Handhabung von temporären Dateien, wie:

    • Wie stellen Sie sicher, dass die Datei gelöscht werden (auch wenn die app abstürzt! Hinweis: FileOption.DeleteOnClose und lassen Sie die kernel-deal with it)
    • , Wie man die richtige caching-Richtlinie für die Datei, um die Leistung zu verbessern (Tipp: FileAttributes.Temporäre)
    • Wie stellen Sie sicher, dass der Inhalt der Datei sicher bleiben, denn:
      • der name der Datei ist noch mehr vorhersehbar, wenn die verwaltete Methode als mit der nicht verwalteten eine
      • die temp-Datei erstellt wird, dann geschlossen, dann bekommst du den Pfad zu (nur um es erneut zu öffnen), damit ein kleines Fenster der Gelegenheit für bösartigen code/Benutzer hijack die Datei.

    C# - Code aus dem Artikel:

    using System;
using System.IO;
using System.Security.Permissions;
using System.Security.Principal;
using System.Security.AccessControl;

public static class PathUtility
{
    private const int defaultBufferSize = 0x1000; //4KB

#region GetSecureDeleteOnCloseTempFileStream

    ///<summary>
    ///Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream.
    ///</summary>
    ///<remarks>
    ///<para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para>
    ///<para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para>
    ///<para>The file is created as a zero-byte file in the system's temporary folder.</para>
    ///<para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para>
    ///<para>The file sharing is set to none.</para>
    ///<para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para>
    ///<para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para>
    ///</remarks>
    ///<returns>The opened <see cref="FileStream"/> object.</returns>
    public static FileStream GetSecureDeleteOnCloseTempFileStream()
    {    
        return GetSecureDeleteOnCloseTempFileStream(defaultBufferSize, FileOptions.DeleteOnClose);    
    }

    ///<summary>
    ///Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream with the specified buffer size.
    ///</summary>
    ///<remarks>
    ///<para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para>
    ///<para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para>
    ///<para>The file is created as a zero-byte file in the system's temporary folder.</para>
    ///<para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para>
    ///<para>The file sharing is set to none.</para>
    ///<para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para>
    ///<para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para>
    ///</remarks>
    ///<param name="bufferSize">A positive <see cref="Int32"/> value greater than 0 indicating the buffer size.</param>
    ///<returns>The opened <see cref="FileStream"/> object.</returns>
    public static FileStream GetSecureDeleteOnCloseTempFileStream(int bufferSize)
    {
        return GetSecureDeleteOnCloseTempFileStream(bufferSize, FileOptions.DeleteOnClose);
    }

    ///<summary>
    ///Creates a unique, randomly named, secure, zero-byte temporary file on disk, which is automatically deleted when it is no longer in use. Returns the opened file stream with the specified buffer size and file options.
    ///</summary>  
    ///<remarks>
    ///<para>The generated file name is a cryptographically strong, random string. The file name is guaranteed to be unique to the system's temporary folder.</para>
    ///<para>The <see cref="GetSecureDeleteOnCloseTempFileStream"/> method will raise an <see cref="IOException"/> if no unique temporary file name is available. Although this is possible, it is highly improbable. To resolve this error, delete all uneeded temporary files.</para>
    ///<para>The file is created as a zero-byte file in the system's temporary folder.</para>
    ///<para>The file owner is set to the current user. The file security permissions grant full control to the current user only.</para>
    ///<para>The file sharing is set to none.</para>
    ///<para>The file is marked as a temporary file. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.</para>
    ///<para>The system deletes the file immediately after it is closed or the <see cref="FileStream"/> is finalized.</para>
    ///<para>Use the <paramref name="options"/> parameter to specify additional file options. You can specify <see cref="FileOptions.Encrypted"/> to encrypt the file contents using the current user account. Specify <see cref="FileOptions.Asynchronous"/> to enable overlapped I/O when using asynchronous reads and writes.</para>
    ///</remarks>
    ///<param name="bufferSize">A positive <see cref="Int32"/> value greater than 0 indicating the buffer size.</param>
    ///<param name="options">A <see cref="FileOptions"/> value that specifies additional file options.</param>
    ///<returns>The opened <see cref="FileStream"/> object.</returns>
    public static FileStream GetSecureDeleteOnCloseTempFileStream(int bufferSize, FileOptions options)
    {    
        FileStream fs = GetSecureFileStream(Path.GetTempPath(), bufferSize, options | FileOptions.DeleteOnClose);

        File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.Temporary);

        return fs;    
    }

#endregion

#region GetSecureTempFileStream

    public static FileStream GetSecureTempFileStream()
    {    
        return GetSecureTempFileStream(defaultBufferSize, FileOptions.None);    
    }

    public static FileStream GetSecureTempFileStream(int bufferSize)
    {
        return GetSecureTempFileStream(bufferSize, FileOptions.None);
    }

    public static FileStream GetSecureTempFileStream(int bufferSize, FileOptions options)
    {
        FileStream fs = GetSecureFileStream(Path.GetTempPath(), bufferSize, options);

        File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.NotContentIndexed | FileAttributes.Temporary);

        return fs;
    }

    #endregion

#region GetSecureTempFileName

    public static string GetSecureTempFileName()
    {    
        return GetSecureTempFileName(false);    
    }

    public static string GetSecureTempFileName(bool encrypted)
    {    
        using (FileStream fs = GetSecureFileStream(Path.GetTempPath(), defaultBufferSize, encrypted ? FileOptions.Encrypted : FileOptions.None))
        {    
            File.SetAttributes(fs.Name, File.GetAttributes(fs.Name) | FileAttributes.NotContentIndexed | FileAttributes.Temporary);

            return fs.Name;    
        }

    }

#endregion

#region GetSecureFileName

    public static string GetSecureFileName(string path)
    {    
        return GetSecureFileName(path, false);    
    }

    public static string GetSecureFileName(string path, bool encrypted)
    {    
        using (FileStream fs = GetSecureFileStream(path, defaultBufferSize, encrypted ? FileOptions.Encrypted : FileOptions.None))
        {    
            return fs.Name;    
        }    
    }

#endregion

#region GetSecureFileStream

    public static FileStream GetSecureFileStream(string path)
    {    
        return GetSecureFileStream(path, defaultBufferSize, FileOptions.None);    
    }

    public static FileStream GetSecureFileStream(string path, int bufferSize)
    {
        return GetSecureFileStream(path, bufferSize, FileOptions.None);
    }

    public static FileStream GetSecureFileStream(string path, int bufferSize, FileOptions options)
    {    
        if (path == null)
            throw new ArgumentNullException("path");

        if (bufferSize <= 0)
            throw new ArgumentOutOfRangeException("bufferSize");

        if ((options & ~(FileOptions.Asynchronous | FileOptions.DeleteOnClose | FileOptions.Encrypted | FileOptions.RandomAccess | FileOptions.SequentialScan | FileOptions.WriteThrough)) != FileOptions.None)
            throw new ArgumentOutOfRangeException("options");

        new FileIOPermission(FileIOPermissionAccess.Write, path).Demand();

        SecurityIdentifier user = WindowsIdentity.GetCurrent().User;

        FileSecurity fileSecurity = new FileSecurity();

        fileSecurity.AddAccessRule(new FileSystemAccessRule(user, FileSystemRights.FullControl, AccessControlType.Allow));

        fileSecurity.SetAccessRuleProtection(true, false);

        fileSecurity.SetOwner(user);

        //Attempt to create a unique file three times before giving up.
        //It is highly improbable that there will ever be a name clash,
        //therefore we do not check to see if the file first exists.

        for (int attempt = 0; attempt < 3; attempt++)
        {    
            try
            {    
                return new FileStream(Path.Combine(path, Path.GetRandomFileName()),
                                        FileMode.CreateNew, FileSystemRights.FullControl,
                                        FileShare.None, bufferSize, options, fileSecurity);
            }

            catch (IOException)
            {
                if (attempt == 2)
                    throw;
            }

        }

        //This code can never be reached.
        //The compiler thinks otherwise.
        throw new IOException();

    }

#endregion

}

    InformationsquelleAutor der Antwort Cristi Diaconescu

  2. 8

    Basiert auf der März-Dateien in meinem " %tmp%, würde ich sagen, nicht.

    Re, warum Sie temporäre - denn das ist Ihre zu erwartende Nutzung. Sie sind nicht system-Dateien; Sie sind nicht-Anwendung Dateien, und Sie sind nicht der Benutzer Dokumente... Sie existieren nur, um eine app zu tun, die temporäre Verarbeitung (vielleicht auf großen Mengen von Daten), oder oft zum übergeben von Daten via IPC zu einem anderen Prozess. Damit Sie wirklich temporär sind.

    Sollten Sie versuchen, löschen Sie alle temporären Dateien, die Sie erstellen, fatal "töten" usw nicht standhalten. Ich benutze oft "mit" - ich erstelle eine wrapper-Klasse, d.h.

    sealed class TempFile : IDisposable { //formatted for space
    string path;
    public string Path {
        get {
            if(path==null) throw new ObjectDisposedException(GetType().Name);
            return path;
        }
    }
    public TempFile() : this(System.IO.Path.GetTempFileName()) { }

    public TempFile(string path) {
        if (string.IsNullOrEmpty(path)) throw new ArgumentNullException("path");
        this.path = path;
    }

    private void Dispose(bool disposing) {
        if (path != null) {
            try {
                File.Delete(path);
            } catch { } //best endeavours...
            path = null;
        }
    }
    public void Dispose() {
        GC.SuppressFinalize(this);
        Dispose(true);
    }
    ~TempFile() {
        Dispose(false);
    }
}

    InformationsquelleAutor der Antwort Marc Gravell

  3. 5

    Es ist ein FileOptions.DeleteOnClose option, die Sie könnten tun, was Sie wollen.

    Hier ist ein link zu der MSDN Seite.

    InformationsquelleAutor der Antwort paul

  4. 1

    Nein, das ist nicht wahr. Im Grunde genommen, ist Ihre Anwendung ist verantwortlich für die Reinigung seiner Durcheinander. Wenn Sie nicht, temporäre Dateien sammeln sich im Laufe der Zeit.

    InformationsquelleAutor der Antwort Mihai Limbășan

  5. 0

    Nein, es liegt in der Verantwortung der software (sprich: Entwickler), die erstellt eine temporäre Datei zu entsorgen.

    Haben einen Blick in Ihre eigenen Ordner "temp", um zu sehen, wie gut das funktioniert 😉

    InformationsquelleAutor der Antwort Treb

  6. 0

    Sind Sie aufgerufen, temporär, weil in den meisten Fällen kann der Benutzer davon ausgehen, Sie können sicher reinigen Sie das Durcheinander in den temp-dirs... Wenn nicht, im Allgemeinen sind diese Dateien gesperrt sind sowieso.

    Im Allgemeinen werden diese Dateien sollten von kurzer Dauer sein: erstellen, verwenden Sie für was auch immer Sie brauchen, haben, löschen Sie Sie auf der Stelle. Im schlimmsten Fall, löschen Sie Sie, wenn Sie die Anwendung beenden.

    Irgendwann, Sie kann nicht, wie zB. ein Archiv-manager oder VCS ermöglicht, zu betrachten, eine Datei mit einem editor (oder auch diff-viewer, etc.), aber geschlossen wird, bevor der editor (oder nicht in der Lage zu überwachen, der erzeugte Prozess...).

    InformationsquelleAutor der Antwort PhiLho

  7. -2

    Ich im internet gelesen habe, eine Menge Zeit, die Menschen nicht wollen, zu verwenden Path.GetTempFileName weil Sie sagen, es könnte zurückkehren, eine bereits vorhandene Datei, um das problem zu lösen, können Sie machen Sie einen Dateinamen ein, basierend auf einer GUID.

    Diese Funktion löst das Problem: Iteriert, bis es findet eine nicht vorhandene Datei mit einer bestimmten Erweiterung.

    VB.net

    Public Shared Function GetTempFileName(ByVal extensionWithDot As String) As String
    Dim tempFileName As String
    Do
        tempFileName = System.IO.Path.GetTempFileName
        If extensionWithDot IsNot Nothing Then
            tempFileName = tempFileName.Replace(System.IO.Path.GetExtension(tempFileName), extensionWithDot)
        End If
    Loop While System.IO.File.Exists(tempFileName)
    Return tempFileName
End Function

    C#:

    public static string GetTempFileName(string extensionWithDot)
{
    string tempFileName = null;
    do {
        tempFileName = System.IO.Path.GetTempFileName;
        if (extensionWithDot != null) {
            tempFileName = tempFileName.Replace(System.IO.Path.GetExtension(tempFileName), extensionWithDot);
        }
    } while (System.IO.File.Exists(tempFileName));
    return tempFileName;
}

    Hinweis: ich benutze argument extensionWithDot weil System.IO.Pfad.GetExtension liefert mit dot.

    InformationsquelleAutor der Antwort Jonh Clark

Schreibe einen Kommentar