¿Hay una versión asincrónica de DirectoryInfo.GetFiles/Directory.GetDirectories en dotNet?

Question

¿Hay una versión asincrónica de DirectoryInfo.GetFiles/Directory.GetDirectories en dotNet? Me gustaría utilizarlos en un bloque asíncrono F #, y sería bueno tener una versión que se pueda llamar con AsyncCallbacks.

Problema es que estoy tratando de absorber un montón de directorios, probablemente en montajes SMB sobre conexiones de red lentas, y no quiero un montón de subprocesos de fila de subprocesos esperando lecturas de red cuando podrían estar haciendo otro trabajo.

Answer 1

No, no creo que exista. El enfoque del hilo de la piscina es probablemente el más pragmático. Alternativamente, supongo que podría bajar a P/Invocar, pero eso sería un lote más trabajo.

Answer 2

no he encontrado una versión asíncrona de GetFiles, sin embargo, si nos fijamos en el código fuente para otras operaciones asíncronas, que están definidos de la siguiente manera:

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) 

En otras palabras, el archivo asíncrono, StreamReader , y las operaciones de WebClient son sólo las envolturas alrededor de las operaciones síncrono, por lo que debe ser capaz de escribir su propia envoltura alrededor GetFiles/GetDirectories de la siguiente manera:

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

la respuesta de la princesa es el camino a seguir para añadir granularidad entre las tareas - por lo este tipo de cosas dejaría oth er jugadores utilizan el grupo de subprocesos:

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

No ayuda tanto cuando cada una de esas llamadas de bloqueo es pesado - y un GetFiles más de SMB es más o menos la definición de pesada.

Tenía la esperanza de que había algún tipo de equivalente para BeginRead/EndRead para los directorios, y que GetFiles/GetDirectories estaba llamadas de bajo nivel sólo un bonito envoltorio alrededor que expusieron algunas variantes asincrónicos. Algo así como BeginReadDir/EndReadDir.

Answer 4

Posiblemente ver varias veces también

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

Answer 5

he utilizado este método para obtener objetos asíncronas de funciones/procedimientos, y siempre funcionaba muy bien:

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

Answer 6

no soy F # programador, pero haría esto en C#:

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

Supongo que hay una construcción similar a los iteradores en F #.

Answer 7

En realidad, de acuerdo con help for Directory.GetFiles, Directory.EnumerateFiles devolverá el primer resultado inmediatamente (es un IEnumerable), en lugar de esperar toda la lista antes de volver. Creo que eso es probablemente lo que estás buscando.

Answer 8

Esto puede considerarse un truco, pero podría considerar usar el UWP StorageFolder API.

ejemplo de C# (aunque F # es probablemente tan fácil):

using Windows.Storage; 

... 

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

Usted fácilmente puede consumir estos de las aplicaciones tradicionales de escritorio .NET y la consola mediante el uso de la biblioteca UWP for Desktop por Luciano Wischik (de Microsoft).

Install-Package UwpDesktop