Sollte Dispose() oder Finalize() verwendet werden, um temporäre Dateien zu löschen?

Ich würde beides machen; stellen Sie die Einweg-Klasse, und haben den finalizer es sauber. Es ist ein standard-Muster für Sie dabei sicher und effektiv: verwenden, anstatt zu versuchen, um daraus für sich selbst was das richtige Muster ist. Es ist sehr leicht etwas falsch laufen. Lesen Sie diese gezielt:

http://msdn.microsoft.com/en-us/library/system.idisposable.aspx

Beachten Sie, dass Sie haben wirklich wirklich vorsichtig beim schreiben ein finalizer. Wenn Sie den finalizer läuft, sind viele der normalen Annahmen sind falsch:

• Gibt es alle möglichen Potentiale für race conditions oder deadlocks, weil du nicht mehr auf dem Haupt-thread, du bist auf der finalizer-thread.

• In normalen code, wenn du den code in ein Objekt, dann wissen Sie, dass all die Dinge, die das Objekt bezieht sich auf die lebendig sind. In einem finalizer, all die Dinge, die das Objekt bezeichnet, könnte gerade abgeschlossen! Finalizer von Toten Objekten ausführen können, in beliebiger Reihenfolge, einschließlich der "Kind" - Objekte Finalisiert werden, bevor Sie "übergeordneten" Objekte.

• In normalen code, Zuweisung einer Referenz auf ein Objekt, um ein statisches Feld sein könnte, durchaus sinnvoll. In einem finalizer, die Referenz, die Sie zuweisen könnte, um eine bereits Toten Objekt, und daher die Zuordnung bringt ein Totes Objekt wieder zum Leben. (Weil Objekte bezeichnet, die durch statische Felder werden immer lebendig.) Das ist ein überaus seltsamen Zustand, und nichts angenehmes passiert, wenn Sie tun.

• Und so weiter. Vorsichtig sein. Sie erwartet voll verstehen, den Betrieb der garbage collector, wenn Sie schreiben, eine nicht-triviale finalizer.

InformationsquelleAutor Eric Lippert

Netter Weise vorgeschlagen, die von David M. Kean auf der MSDN-Eintrag auf Weg.GetTempFileName. Er erzeugt eine wrapper-Klasse die IDisposable wird automatisch entfernen Sie die Datei:

public class TemporaryFile : IDisposable
{
    private bool _isDisposed;

    public bool Keep { get; set; }
    public string Path { get; private set; }

    public TemporaryFile() : this(false)
    {
    }

    public TemporaryFile(bool shortLived)
    {
        this.Path = CreateTemporaryFile(shortLived);
    }

    ~TemporaryFile()
    {
        Dispose(false);
    }

    public void Dispose()
    {
        Dispose(false);
        GC.SuppressFinalize(this);
    } 

    protected virtual void Dispose(bool disposing)
    {
        if (!_isDisposed)
        {
            _isDisposed = true;

            if (!this.Keep)
            {
                TryDelete();   
            }
        }
    }

    private void TryDelete()
    {
        try
        {
            File.Delete(this.Path);
        }
        catch (IOException)
        {
        }
        catch (UnauthorizedAccessException)
        {
        }
    }

    public static string CreateTemporaryFile(bool shortLived)
    {
        string temporaryFile = System.IO.Path.GetTempFileName();

        if (shortLived)
        { 
            //Set the temporary attribute, meaning the file will live 
            //in memory and will not be written to disk 
            //
            File.SetAttributes(temporaryFile, 
                File.GetAttributes(temporaryFile) | FileAttributes.Temporary);
        }

        return temporaryFile;
    }
}

Mithilfe der neuen Klasse ist einfach, geben Sie den folgenden:

using (TemporaryFile temporaryFile = new TemporaryFile())
{
    //Use temporary file
}

Wenn Sie sich entscheiden, nach dem Bau einer TemporaryFile, dass Sie möchten, um zu verhindern, dass es gelöscht wird, legen Sie einfach die TemporaryFile.Halten Sie die Eigenschaft auf "true":

using (TemporaryFile temporaryFile = new TemporaryFile()) 
{ 
    temporaryFile.Keep = true; 
}

InformationsquelleAutor Dirk Vollmar

Wenn Sie möchten, re-verwenden Sie Ihre temporären Dateien z.B. open\close\read\write\etc, dann clearing-up auf die AppDomain entladen Ebene nützlich sein kann.

Dies kann verwendet werden, in Kombination mit dem setzen von temp-Dateien in einem bekannten sub-Verzeichnis eine temp Lage und sicherstellen, dass das Verzeichnis gelöscht wird beim starten der Anwendung, um sicherzustellen, unsauberen Shutdowns gesorgt.

Einem einfachen Beispiel an die Technik (mit Ausnahmebehandlung entfernt, um löschen aus Platzgründen). Ich verwende diese Technik in der file-basierten unit-tests, wo es Sinn macht und nützlich ist.

public static class TempFileManager
{
    private static readonly List<FileInfo> TempFiles = new List<FileInfo>();
    private static readonly object SyncObj = new object();

    static TempFileManager()
    {
        AppDomain.CurrentDomain.DomainUnload += CurrentDomainDomainUnload;
    }

    private static void CurrentDomainDomainUnload(object sender, EventArgs e)
    {
        TempFiles.FindAll(file => File.Exists(file.FullName)).ForEach(file => file.Delete());
    }

    public static FileInfo CreateTempFile(bool autoDelete)
    {
        FileInfo tempFile = new FileInfo(Path.GetTempFileName());

        if (autoDelete)
        {
            lock (SyncObj)
            {
                TempFiles.Add(tempFile);
            }
        }

        return tempFile;
    }
}

InformationsquelleAutor Tim Lloyd

Sollten Sie auf jeden Fall nutzen Dispose um die Ressourcen zu bereinigen, aber stellen Sie sicher, dass Sie implementieren die IDisposable - Schnittstelle. Sie wollen nicht einfach nur fügen Sie eine Methode namens Dispose.

InformationsquelleAutor Tim Coker