Как максимально эффективно обрабатывать большое количество одновременных запросов на запись на диск

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

private void WriteFileSynchronous(string FileName, MemoryStream Data)
{
    Task.Factory.StartNew(() => WriteFileSynchronously(FileName, Data));
}

private void WriteFileSynchronous(string FileName, MemoryStream Data)
{
    try
    {
        using (FileStream DiskFile = File.OpenWrite(FileName))
        {
            Data.WriteTo(DiskFile);
            DiskFile.Flush();
            DiskFile.Close();
        }
    }

    catch (Exception e)
    {
        Console.WriteLine(e.Message);
    }
}

TPL использует внутренний пул потоков и должен быть достаточно эффективным даже для большого количества задач.

Если вы хотите вернуться быстро и не заботитесь о том, чтобы операция была синхронной, вы можете создать какую-то память в памяти Queue, куда вы будете помещать запросы на запись, и пока очередь не заполнена, вы можете быстро вернуться из метода. Другой поток будет отвечать за отправку Queue и запись файлов. Если ваш WriteFile вызывается и очередь заполнена, вам придется подождать, пока вы не сможете поставить в очередь, и выполнение снова станет синхронным, но таким образом у вас может быть большой буфер, поэтому, если запросы на запись в файл процесса не являются линейными, а вместо этого более острыми ( с паузами между всплесками вызовов записи файла) такое изменение можно рассматривать как улучшение вашей производительности.

ОБНОВЛЕНИЕ: Сделал для вас небольшую картинку. Обратите внимание, что узкое место существует всегда, все, что вы можете сделать, это оптимизировать запросы с помощью очереди. Обратите внимание, что очередь имеет ограничения, поэтому, когда она заполнена, вы не можете помещать файлы в очередь, вам нужно подождать, чтобы в этом буфере также было свободное место. Но для ситуации, представленной на картинке (3 запроса корзины), очевидно, что вы можете быстро поставить корзины в очередь и вернуться, в то время как в первом случае вы должны сделать это по одной и заблокировать выполнение.

Обратите внимание, что вам никогда не нужно выполнять много потоков ввода-вывода одновременно, так как все они будут использовать одно и то же узкое место, и вы просто будете тратить память, если попытаетесь распараллелить это сильно, я полагаю, что 2-10 потоков максимум легко захватят всю доступную пропускную способность ввода-вывода. , а также ограничит использование памяти приложения.

Если данные поступают быстрее, чем вы можете их зарегистрировать, у вас есть реальная проблема. Дизайн производителя/потребителя, в котором WriteFile просто помещается материал в ConcurrentQueue или подобную структуру, а отдельный поток, обслуживающий эту очередь, отлично работает ... до тех пор, пока очередь не заполнится. И если вы говорите об открытии 50 000 различных файлов, резервное копирование будет происходить быстро. Не говоря уже о том, что ваши данные, которые могут составлять несколько мегабайт для каждого файла, будут еще больше ограничивать размер вашей очереди.

У меня была аналогичная проблема, которую я решил, добавив метод WriteFile к одному файлу. Записи, которые он записывал, имели номер записи, имя файла, длину, а затем данные. Как указал Ханс в комментарии к вашему исходному вопросу, запись в файл выполняется быстро; открытие файла происходит медленно.

Второй поток в моей программе начинает читать файл, в который пишет WriteFile. Этот поток читает заголовок каждой записи (номер, имя файла, длина), открывает новый файл, а затем копирует данные из файла журнала в окончательный файл.

Это работает лучше, если файл журнала и окончательный файл находятся на разных дисках, но все же может работать с одним шпинделем. Тем не менее, это, безусловно, тренирует ваш жесткий диск.

Его недостатком является необходимость в 2 раза больше места на диске, но с 2-терабайтными дисками стоимостью менее 150 долларов я не считаю это большой проблемой. Кроме того, в целом это менее эффективно, чем прямая запись данных (поскольку вам приходится обрабатывать данные дважды), но имеет то преимущество, что основной поток обработки не останавливается.

Инкапсулируйте полную реализацию метода в новый файл Thread(). Затем вы можете «запустить и забыть» эти потоки и вернуться к основному вызывающему потоку.

    foreach (file in filesArray)
    {
        try
        {
            System.Threading.Thread updateThread = new System.Threading.Thread(delegate()
                {
                    WriteFileSynchronous(fileName, data);
                });
            updateThread.Start();
        }
        catch (Exception ex)
        {
            string errMsg = ex.Message;
            Exception innerEx = ex.InnerException;
            while (innerEx != null)
            {
                errMsg += "\n" + innerEx.Message;
                innerEx = innerEx.InnerException;
            }
            errorMessages.Add(errMsg);
        }
    }