Warten für das system zu löschen die Datei

Hatte ich ein problem mit erfrischenden Dateiliste nach dem löschen einer Datei. Wenn ich gab Befehl zum löschen der Datei, die exception geworfen wurde, weil die refresh-Methode versucht auf eine Datei zuzugreifen, wurde die gelöscht werden soll.

Nach einiger überlegung und debugging kam ich zu dem Schluss, dass problem war in der Tat, das system braucht einige Zeit, um eine Datei zu löschen. Und ich löse es wie folgt:

//Deleting file
System.Threading.Thread.Sleep(2000);
//Refreshing list

und es funktionierte gut.

Meine Frage ist

Gibt es eine elegantere Möglichkeit zu warten, für system tun, löschen Sie die Datei und fahren Sie dann mit code...?

Können wir sehen, der rest des code aus? Auch, welche Art von Dateisystem (lokales NTFS oder irgendeine form von NFS)? Die meisten filesystem delete-Operationen, die auf NTFS sowieso, sind atomar.
Es ist auf NTFS. Welchen Teil des Codes, die Sie interessieren. Delete-Methode rekursiv löscht alle Dateien im Verzeichnis und das Verzeichnis selbst. Ich hätte nicht gedacht, dass das relevant ist, so sagte ich, dass ich brauchen, um eine Datei zu löschen ... Es ist die gleiche Sache, nicht wahr?
Überhaupt nicht. Ich lasse eine Antwort
Bitte Lesen Sie meine post, ich gerade aktualisiert die MSDN-link von FileSystemWatcher zu zeigen .NET 4.0 anstelle von 1.1

InformationsquelleAutor kr85 | 2012-02-20

c#delete-file filesystems multithreading

6

Die eleganteste Art, wie ich denken kann, ist mit einem FileSystemWatcher und abonnieren Sie Ihre Deleted Veranstaltung.
- Wenn dies auf einer NFS-partition, wie ich vermute, dann ist es FileSystemWatcher kann nicht zuverlässig sein: stackoverflow.com/questions/239988/...
- Ich habe nur verwendet dies auf einem NTFS-system und es funktioniert einfach toll. Nicht sicher über NFS wenn
- Zu komplizierte Lösung, die ich vermute
- Nein, überhaupt nicht. Es gibt immer viele Möglichkeiten oder die Lösung eines Problems. Wenn Sie etwas elegant, dann ist dies der Weg zu gehen.
InformationsquelleAutor GETah

Diese funktioniert bei mir:

public static void DeleteFile(String fileToDelete)
{
    var fi = new System.IO.FileInfo(fileToDelete);
    if (fi.Exists)
    {
        fi.Delete();
        fi.Refresh();
        while (fi.Exists)
        {    System.Threading.Thread.Sleep(100);
             fi.Refresh();
        }
    }
}

Finde ich, dass die meisten der Zeit, wird die while-Schleife wird nicht mehr betreten werden.

InformationsquelleAutor Mike G

Leicht-code FileSystemWatcher, abonnieren Sie Ihre Deleted Ereignis und warten.

void DeleteFileAndWait(string filepath, int timeout = 30000)
{
    using (var fw = new FileSystemWatcher(Path.GetDirectoryName(filepath), Path.GetFileName(filepath)))
    using (var mre = new ManualResetEventSlim())
    {
        fw.EnableRaisingEvents = true;
        fw.Deleted += (object sender, FileSystemEventArgs e) =>
        {
            mre.Set();
        };
        File.Delete(filepath);
        mre.Wait(timeout);
    }
}

InformationsquelleAutor JPK

Hier ist etwas code, mit dem FileWatcher. Was wir wollen in der Lage sein zu tun ist,

await Utils.DeleteDirectoryAsync("c:\temp\foo", recurse: true);

den unten implementiert

using System;
using System.IO;
using System.Reactive;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Threading.Tasks;

namespace Utils
{
    internal class FileWatcher : IDisposable
    {
        readonly FileSystemWatcher _Watcher;

        public Subject<FileSystemEventArgs> Changed = new Subject<FileSystemEventArgs>();

        public FileWatcher( string file )
        {
            //Create a new FileSystemWatcher and set its properties.
            _Watcher = new FileSystemWatcher
                       {
                           Path = Path.GetDirectoryName(file),
                           NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
                                          | NotifyFilters.FileName | NotifyFilters.DirectoryName,
                           Filter =Path.GetFileName(file) 
                       };

            //Add event handlers.
            _Watcher.Changed += OnChanged;
            _Watcher.Created += OnChanged;
            _Watcher.Deleted += OnChanged;
            _Watcher.Renamed += OnChanged;

            //Begin watching.
            _Watcher.EnableRaisingEvents = true;
        }

        //Define the event handlers.
        private void OnChanged( object source, FileSystemEventArgs e )
        {
            Changed.OnNext(e);
        }


        public void Dispose()
        {
            _Watcher.Dispose();
        }
    }
}

und einige utils, nutzen Sie die oben zu beobachten.

public static class FileUtils
{
    public static IObservable<FileSystemEventArgs> ChangedObservable(string path)
    {
        if (path == null)
            return Observable.Never<FileSystemEventArgs>();

        return Observable.Using(() => new FileWatcher(path), watcher => watcher.Changed);
    }

    public static Task DeleteDirectoryAsync(string path, bool recurse)
    {
        var task = new TaskCompletionSource<Unit>();

        if (Directory.Exists(path))
        {
            ChangedObservable(path)
                .Where(f => f.ChangeType == WatcherChangeTypes.Deleted)
                .Take(1)
                .Subscribe(v => task.SetResult(Unit.Default));

            Directory.Delete(path, recurse);
        }
        else
        {
            task.SetResult(Unit.Default);
        }

        return task.Task;
    }
}

InformationsquelleAutor bradgonesurfing

1

Ich immer diese verwendet:
```
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
```
Sehen hier und hier

InformationsquelleAutor Vadim
0

Löschen ein Verzeichnis mit - Verzeichnis.Löschen, speziell die überlast, die es braucht, 'recursive' boolean, auf NTFS, sollte eine Atomare operation aus Ihrer Sicht des Programms. Keine Notwendigkeit, recurse manuell selbst.
- Sollte es sein, ist es aber nicht. - Verzeichnis.Vorhanden ist, wird manchmal true zurück, vor allem, wenn es die nächste Zeile. Noch Schlimmer, Verzeichnis.Erstellen, manchmal werfen, wenn man zu schnell nach dem Verzeichnis.Löschen.
InformationsquelleAutor Chris Shain
0

Verzeichnis.Löschen, wird eine Ausnahme ausgelöst, die auf den ersten Fehler, auf die es trifft. Wenn Sie fortfahren möchten, löschen Sie so viele Dateien und Unterverzeichnisse, wie Sie können, dann sollten Sie nicht verwenden-Verzeichnis.Löschen Sie und schreiben Sie Ihre eigene rekursive löschen mit try/catch-Blöcke im inneren des loops. Ein Beispiel, möchten Sie vielleicht zu tun ist, wenn Sie versuchen, die Bereinigung von temp-Dateien und eine der Dateien, die gesperrt wurde.

InformationsquelleAutor Valerie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.