Gibt es in dotNet eine asynchrone Version von DirectoryInfo.GetFiles/Directory.GetDirectories?

Question

Gibt es in dotNet eine asynchrone Version von DirectoryInfo.GetFiles/Directory.GetDirectories? Ich möchte sie in einem Async-Block F # verwenden, und es wäre nett, eine Version zu haben, die mit AsyncCallbacks aufgerufen werden kann.

Problem ist, ich versuche, eine Reihe von Verzeichnissen, wahrscheinlich auf SMB Mounts über langsame Netzwerkverbindungen zu saugen, und ich möchte nicht eine Reihe von Thread-Pool-Threads herumstehen warten auf Netzwerk liest, wenn sie tun könnten andere Arbeit.

Answer 1

Nein, das glaube ich nicht. Der Pool-Thread-Ansatz ist wahrscheinlich der pragmatischste. Alternativ, ich denke, Sie könnten auf P/Invoke fallen - aber das wäre ein Los mehr Arbeit.

Answer 2

ich keine Asynchron-Version von GetFiles gefunden haben, aber wenn Sie für andere Async Operationen am Quelltext aussehen, sind sie wie folgt definiert:

module FileExtensions = 

     let UnblockViaNewThread f = 
      async { //let ctxt = System.Threading.SynchronizationContext.Current 
        do! Async.SwitchToNewThread() 
        let res = f() 
        do! Async.SwitchToThreadPool() 
        //do! Async.SwitchTo ctxt 
        return res } 

     type System.IO.File with 
      static member AsyncOpenText(path) = UnblockViaNewThread (fun() -> System.IO.File.OpenText(path)) 
      static member AsyncAppendText(path) = UnblockViaNewThread (fun() -> System.IO.File.AppendText(path)) 
      static member AsyncOpenRead(path) = UnblockViaNewThread (fun() -> System.IO.File.OpenRead(path)) 
      static member AsyncOpenWrite(path) = UnblockViaNewThread (fun() -> System.IO.File.OpenWrite(path)) 
      static member AsyncOpen(path,mode,?access,?share) = 
       let access = match access with Some v -> v | None -> System.IO.FileAccess.ReadWrite 
       let share = match share with Some v -> v | None -> System.IO.FileShare.None 
       UnblockViaNewThread (fun() -> System.IO.File.Open(path,mode,access,share)) 

      static member OpenTextAsync(path) = System.IO.File.AsyncOpenText(path) 
      static member AppendTextAsync(path) = System.IO.File.AsyncAppendText(path) 
      static member OpenReadAsync(path) = System.IO.File.AsyncOpenRead(path) 
      static member OpenWriteAsync(path) = System.IO.File.AsyncOpenWrite(path) 
      static member OpenAsync(path,mode,?access,?share) = System.IO.File.AsyncOpen(path, mode, ?access=access, ?share=share) 

Mit anderen Worten, die Async-Datei, Stream und WebClient Operationen sind nur Wrapper um die syncronous Operationen, so sollten Sie in der Lage sein, Ihren eigenen Wrapper um GetFiles/GetDirectories zu schreiben, wie folgt:

module IOExtensions = 
    type System.IO.Directory with 
     static member AsyncGetFiles(directory) = async { return System.IO.Directory.GetFiles(directory) } 
     static member AsyncGetDirectories(path) = async { return System.IO.Directory.GetDirectories(path) } 

Answer 3

Princess Antwort ist die Art und Weise für das Hinzufügen von Granularität zwischen Aufgaben zu gehen - so diese Art von Sache würde sich lohnen er Spieler verwenden, um den Thread-Pool:

let! x = OpenTextAsync("whatever"); 
// opening for something else to run 
let! x = OpenTextAsync("whatever"); 
// opening for something else to run 
let! x = OpenTextAsync("whatever"); 

Es nicht so viel helfen, wenn jeder dieser blockierende Aufrufe ist schwer - und ein GetFiles über SMB ist so ziemlich die Definition von schweren.

Ich hatte gehofft, es war eine Art Äquivalent für BeginRead/EndRead für Verzeichnisse und dass GetFiles/GetDirectories war nur eine nette Wrapper um niedrigerer Ebene Anrufe, die einige Asynchron-Varianten ausgesetzt. Etwas wie BeginReadDir/EndReadDir.

Answer 4

Möglicherweise auch

http://weblogs.asp.net/podwysocki/archive/2009/03/18/functional-net-laziness-becomes-you.aspx

Answer 5

Ich habe mehrmals diesen Ansatz verwendet, um Async Objekte von Funktionen/Prozeduren zu erhalten, und es funktionierte immer gut:

let AsyncGetDirectories path = 
    let fn = new Func<_, _>(System.IO.Directory.GetDirectories) 
    Async.BuildPrimitive(path, fn.BeginInvoke, fn.EndInvoke) 

Answer 6

Ich bin kein F # Programmierer, aber ich würde dies in C# tun:

static IEnumerable<string> IterateFiles(string path, string pattern) { 
    var entryQueue = new Queue<string>(); 
    entryQueue.Enqueue(path); 

    while (entryQueue.Count > 0) { 
     var subdirs = Directory.GetDirectories(entryQueue.Peek()); 
     var files = Directory.GetFiles(entryQueue.Peek(), pattern, SearchOption.TopDirectoryOnly); 
     foreach (var file in files) 
      yield return file; 
     entryQueue.Dequeue(); 

     foreach(var subdir in subdirs) 
      entryQueue.Enqueue(subdir); 
    } 
} 

Ich nehme an, dass es ein ähnliches Konstrukt zu Iteratoren in F # gibt.

Answer 7

Eigentlich, nach der help for Directory.GetFiles, wird Directory.EnumerateFiles das erste Ergebnis sofort zurückgeben (es ist ein IEnumerable), anstatt auf die gesamte Liste vor der Rückkehr warten. Ich glaube, das ist wahrscheinlich das, wonach Sie suchen.

Answer 8

Dies kann als ein bisschen ein Hack betrachtet werden, aber Sie könnten die Verwendung der UWP StorageFolder API in Betracht ziehen.

C# Beispiel (obwohl F # wahrscheinlich genauso einfach ist):

using Windows.Storage; 

... 

var folder = await StorageFolder.GetFolderFromPathAsync(path); 
var files = await folder.GetFilesAsync(); 
var folders = await folder.GetFoldersAsync(); 

Sie können ganz einfach verbrauchen diese von Anwendungen traditionellen .NET Desktop und Konsole der UWP for Desktop Bibliothek von Lucian Wischik unter Verwendung von (von Microsoft).

Install-Package UwpDesktop