c# - example - File.Copy en Parallel.ForEach

task c#

Question

Hola, intento crear dir y copiar archivo (pdf) en Parallel.ForEach ...

Creo un ejemplo simple:

 private static void CreateFolderAndCopyFile(int index)
{
const string sourcePdfPath = "c://testdata//test.pdf";
const string rootPath = "c://testdata";
string folderDirName = string.Format("Data{0}", string.Format("{0:00000000}", index));
string folderDirPath = rootPath + @"/" + folderDirName;
Directory.CreateDirectory(folderDirPath);
string desPdfPath = folderDirPath + @"/" + "test.pdf";
File.Copy(sourcePdfPath, desPdfPath, true);
}

El método anterior crea una nueva carpeta y copia el archivo pdf a la nueva carpeta. Crea este árbol de directorios:

TESTDATA
-Data00000000
-test.pdf
-Data00000001
-test.pdf
....
-Data0000000N
-test.pdf

Llamo al método CreateFolderAndCopyFile en Parallel.ForEach loop.

 private static void Func<T>(IEnumerable<T> docs)
{
int index = 0;
Parallel.ForEach(docs, doc =>
{
CreateFolderAndCopyFile(index);
index++;
});
}

Si intento ejecutar este código, terminará con un error:

El proceso no puede acceder al archivo ''c: / testdata / Data00001102 / test.pdf'' porque está siendo utilizado por otro proceso.

Pero primero creó 1111 nuevas carpetas y copió test.pdf unas 1111 veces y obtuve este error.

¿Qué causa este comportamiento y cómo resolverlo?

EDITADO:

El código anterior era una muestra de juguete, lo siento por las cadenas codificadas. Conclusión: método paralelo si lento.

Mañana pruebo algunos métodos de ¿Cómo escribir código de transmisión de archivos súper rápido en C #? .

especialmente: http://designingefficientsoftware.wordpress.com/2011/03/03/efficient-file-io-from-csharp/

Answer 1

No está sincronizando el acceso al index y eso significa que tiene una carrera en él. Es por eso que tienes el error. A modo ilustrativo, puede evitar la carrera y mantener este diseño particular utilizando Interlocked.Increment .

private static void Func<T>(IEnumerable<T> docs)
{
int index = -1;
Parallel.ForEach(
docs, doc =>
{
int nextIndex = Interlocked.Increment(index);
CreateFolderAndCopyFile(nextIndex);
}
);
}

Sin embargo, como otros sugieren, la sobrecarga alternativa de ForEach que proporciona un índice de ciclo es claramente una solución más limpia para este problema en particular.

Pero cuando lo haces funcionar, encontrarás que copiar archivos está vinculado a IO en lugar de a un procesador y predigo que el código paralelo será más lento que el código de serie.

Answer 2

Su operación de incremento en el index es sospechosa ya que no es segura para subprocesos. Si cambia la operación a Console.WriteLine("{0}", index++) verá este comportamiento.

En su lugar, podría usar una sobrecarga de Parallel.ForEach con un índice de bucle:

private static void Func<T>(IEnumerable<T> docs)
{
// nb: index is ''long'' not ''int''
Parallel.ForEach(docs, (doc, state, index) =>
{
CreateFolderAndCopyFile(index);
});
}