C# Image.FromFile - Массовая операция?

Итак, я написал функцию, которая будет выполнять работу, распределенную по нескольким потокам, - а затем обнаружил «ошибку» в моем коде. (Однако использование многопоточности очень помогает, поэтому image.fromFile явно ограничен процессором, а не (локальным) SSD).

1.) Сетевая загрузка

В коде, упомянутом выше: System.IO.FileInfo[] files2 = di.EnumerateFiles("*.jpg", SearchOption.AllDirectories).ToArray(); - я использовал для перечисления di, а не di2 (di относится к общему сетевому ресурсу)

(так что Array.ConvertAll имел доступ к удаленным файлам)

Время выполнения «этого» подхода: 6с 414 мс

2.) Местная загрузка

Исправление этого привело к запуску 1 с 886 мс

3.) Загрузка с локальной резьбой

Однако моя функция ThreadedLoading уже была выполнена, поэтому я тоже попробовал:

0 с 543 мс - все еще почти в 4 раза быстрее на 8-ядерном с 4 физическими ядрами.

Вот код. Возможно, еще не пуленепробиваемый, но дает надежные и быстрые (расчетные) результаты.

использование:

 DateTime t1 = DateTime.Now;
//Image[] images = Array.ConvertAll(files2, file => Image.FromFile(file.FullName));
Image[] images = loadImagesThreaded(files2);
DateTime t2 = DateTime.Now;

TimeSpan ts = t2.Subtract(t1);
MessageBox.Show("Loading took: " + ts.Seconds + "s " + ts.Milliseconds + "ms"); //6s 414ms

Resources.ProductImageList_256.Images.AddRange(images);

Функция:

private Image[] loadImagesThreaded(FileInfo[] files)
{
    int threadCount = 8;
    int chunkSize = files.Length / threadCount; //Round about -  doesn't need to be precise. 
    Thread[] threads = new Thread[threadCount];
    Image[][] result = new Image[threadCount][];

    for (int i = 0; i < threadCount; i++)
    {
        FileInfo[] chunk;
        int lowerBound = i * chunkSize;
        if (i < threadCount - 1)
        {
            chunk = files.Skip(lowerBound).Take(chunkSize).ToArray();
        }
        else
        {
            //take the rest
            chunk = files.Skip(lowerBound).ToArray();
        }

        int j = i; 
        threads[i] = new Thread(() =>
        {
            result[j] = Array.ConvertAll(chunk, file => Image.FromFile(file.FullName));
        });
        threads[i].Start();
    }

    //wait for threads to finish. 
    Boolean oneAlive = true;
    while (oneAlive)
    {
        oneAlive = false;
        foreach (Thread t in threads)
        {
            if (t.IsAlive)
            {
                oneAlive = true;
                break;
            }
        }
    }

    //all done. 
    Image[] finalResult = new Image[files.Count()];
    for (int i = 0; i < threadCount; i++)
    {
        int lowerBound = i * chunkSize;
        result[i].CopyTo(finalResult, lowerBound);
    }
    return finalResult;
}

разве это не приятный пик при предварительной загрузке изображений? :-)

4.) Parallel.ForEach

По рекомендации Фелипе Рамоса я попробовал Parallel.ForEach. Это примерно на 40-50 мс быстрее, чем мое «многопоточное» решение (в основном получающееся 480-500 мс), но, возможно, более важный факт:

Я бы сказал, что это несложно и, следовательно, более надежно:

Image[] images = new Image[files2.Count()];
Parallel.ForEach(files2, (fileInfo, state, index) =>
{
    images[index] = Image.FromFile(fileInfo.FullName);
});

DateTime t2 = DateTime.Now;
TimeSpan ts = t2.Subtract(t1);
MessageBox.Show("Loading took: " + ts.Seconds + "s " + ts.Milliseconds + "ms");