Есть ли асинхронная версия DirectoryInfo.GetFiles / Directory.GetDirectories в dotNet?

Question

Существует ли асинхронная версия DirectoryInfo.GetFiles / Directory.GetDirectories в dotNet? Я хотел бы использовать их в асинхронном блоке F#, и было бы неплохо иметь версию, которую можно вызывать с помощью AsyncCallbacks.

Проблема в том, что я пытаюсь засосать кучу каталогов, возможно, при монтировании SMB через медленные сетевые соединения, и я не хочу, чтобы куча потоков пулов сидела без дела, ожидая сетевых чтений, когда они могли бы выполнять другую работу.

Answer 1

Нет, я не думаю, что есть. Подход с использованием пула потоков, пожалуй, самый прагматичный. В качестве альтернативы, я думаю, вы могли бы перейти к P/Invoke - но это было бы намного больше работы.

Answer 2

Я не нашел асинхронную версию GetFiles, однако, если вы посмотрите на исходный код для других асинхронных операций, они определены следующим образом:

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)

Другими словами, операции Async file, streamreader и WebClient являются просто оболочками для синхронных операций, поэтому вы должны иметь возможность написать свою собственную оболочку для GetFiles/GetDirectories следующим образом:

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

Это может считаться хаком, но вы можете рассмотреть возможность использования UWP StorageFolder API.

Пример C# (хотя F#, вероятно, так же просто):

using Windows.Storage;

...

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

Вы можете легко использовать их из традиционных настольных и консольных приложений.NET, используя библиотеку UWP for Desktop от Lucian Wischik (от Microsoft).

Install-Package UwpDesktop

Answer 4

На самом деле, согласно помощи дляDirectory.GetFiles, Directory.EnumerateFiles вернет первый результат немедленно (это IEnumerable), а не ждать весь список, прежде чем вернуться. Я считаю, что это, вероятно, то, что вы ищете.

Answer 5

Я несколько раз использовал этот подход для получения объектов Async из функций / процедур, и он всегда работал отлично:

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

Answer 6

Возможно также увидеть

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

Answer 7

Ответ принцессы - это способ добавить детализацию между задачами - так что подобные вещи позволят другим игрокам использовать пул потоков:

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

Это не очень помогает, когда каждый из этих блокирующих вызовов тяжелый - а GetFiles over SMB - это в значительной степени определение тяжелого.

Я надеялся, что есть какой-то эквивалент для BeginRead/EndRead для каталогов, и это GetFiles/GetDirectories была просто хорошей оберткой вокруг вызовов более низкого уровня, которые выставляли некоторые асинхронные варианты. Что-то вроде BeginReadDir/EndReadDir,

Answer 8

Я не программист F#, но я бы сделал это на 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);
    }
}

Я предполагаю, что итераторы в F# похожи по конструкции.