Comment : itérer les répertoires de fichiers avec la classe parallèle
Dans de nombreux cas, l'itération de fichier est une opération qui peut facilement être parallélisée. La rubrique Comment : itérer les répertoires de fichiers avec PLINQ indique le moyen le plus simple d'effectuer cette tâche dans de nombreux scénarios. Toutefois, des problèmes peuvent se produire lorsque votre code doit traiter les nombreux types d'exceptions qui peuvent survenir lors de l'accès au système de fichiers. L'exemple suivant indique une méthode pour faire face à ce problème. Elle utilise une itération basée sur la pile pour parcourir tous les fichiers et dossiers d'un répertoire spécifié, et permet à votre code d'intercepter et de traiter diverses exceptions. Évidemment, le choix du traitement des exceptions vous appartient.
Exemple
Dans l'exemple suivant, l'itération au sein des répertoires est exécutée de manière séquentielle, mais le traitement des fichiers s'effectue en parallèle. Il s'agit probablement de la méthode la mieux adaptée si vous avez un ratio fichier/répertoire élevé. Il est également possible de paralléliser l'itération des répertoires et d'accéder à chaque fichier séquentiellement. Ce n'est probablement pas très efficace de paralléliser les deux boucles sauf si vous ciblez spécifiquement un ordinateur doté d'un grand nombre de processeurs. Toutefois, comme dans tous les cas, vous devez tester votre application de manière approfondie afin de déterminer la meilleure méthode.
Imports System
Imports System.Collections.Generic
Imports System.Diagnostics
Imports System.IO
Imports System.Linq
Imports System.Text
Imports System.Threading
Imports System.Threading.Tasks
Module Parallel_File
Sub Main(ByVal args() As String)
TraverseTreeParallelForEach("C:\Program Files", Sub(f)
' For this demo we don't do anything with the data
' except to read it.
Dim data() As Byte = File.ReadAllBytes(f)
' For user interest, although it slows down the operation.
Console.WriteLine(f)
End Sub)
' Keep the console window open.
Console.ReadKey()
End Sub
Public Sub TraverseTreeParallelForEach(ByVal root As String, ByVal action As Action(Of String))
'Count of files traversed and timer for diagnostic output
Dim fileCount As Integer = 0
Dim sw As Stopwatch = Stopwatch.StartNew()
' Use this value to determine whether to parallelize
' file processing on each folder.
Dim procCount As Integer = System.Environment.ProcessorCount
' Data structure to hold names of subfolders to be
' examined for files.
Dim dirs As Stack(Of String) = New Stack(Of String)
If System.IO.Directory.Exists(root) = False Then
Throw New ArgumentException()
End If
dirs.Push(root)
While (dirs.Count > 0)
Dim currentDir As String = dirs.Pop()
Dim subDirs() As String = Nothing
Dim files() As String = Nothing
Try
subDirs = System.IO.Directory.GetDirectories(currentDir)
' An UnauthorizedAccessException exception will be thrown if we do not have
' discovery permission on a folder or file. It may or may not be acceptable
' to ignore the exception and continue enumerating the remaining files and
' folders. It is also possible (but unlikely) that a DirectoryNotFound exception
' will be raised. This will happen if currentDir has been deleted by
' another application or thread after our call to Directory.Exists. The
' choice of which exceptions to catch depends entirely on the specific task
' you are intending to perform and also on how much you know with certainty
' about the systems on which this code will run.
Catch e As UnauthorizedAccessException
Console.WriteLine(e.Message)
Continue While
Catch e As System.IO.DirectoryNotFoundException
Console.WriteLine(e.Message)
Continue While
End Try
Try
files = System.IO.Directory.GetFiles(currentDir)
Catch e As UnauthorizedAccessException
Console.WriteLine(e.Message)
Continue While
Catch e As System.IO.DirectoryNotFoundException
Console.WriteLine(e.Message)
Continue While
End Try
' Perform the required action on each file here in parallel
' if there are a sufficient number of files in the directory
' or else sequentially if not. Files are opened and processed
' synchronously but this could be modified to perform async I/O.
Try
If files.Length < procCount Then
For Each file In files
action(file)
fileCount = fileCount + 1
Next
Else
Parallel.ForEach(files, Function() 0, Function(file, loopState, localCount)
action(file)
localCount = localCount + 1
Return CType(localCount, Integer)
End Function,
Sub(c)
Interlocked.Exchange(fileCount, fileCount + c)
End Sub)
End If
Catch ae As AggregateException
ae.Handle(Function(ex)
If TypeOf (ex) Is UnauthorizedAccessException Then
' Here we just output a message and go on.
Console.WriteLine(ex.Message)
Return True
End If
' Handle other exceptions here if necessary...
Return False
End Function)
End Try
' Push the subdirectories onto the stack for traversal.
' This could also be done before handing the files.
For Each str As String In subDirs
dirs.Push(str)
Next
' For diagnostic purposes.
Console.WriteLine("Processed {0} files in {1} milleseconds", fileCount, sw.ElapsedMilliseconds)
End While
End Sub
End Module
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Parallel_File
{
class Program
{
static void Main(string[] args)
{
TraverseTreeParallelForEach(@"C:\Program Files", (f) =>
{
// For this demo we don't do anything with the data
// except to read it.
byte[] data = File.ReadAllBytes(f);
// For user interest, although it slows down the operation.
Console.WriteLine(f);
});
// Keep the console window open.
Console.ReadKey();
}
public static void TraverseTreeParallelForEach(string root, Action<string> action)
{
//Count of files traversed and timer for diagnostic output
int fileCount = 0;
var sw = Stopwatch.StartNew();
// Use this value to determine whether to parallelize
// file processing on each folder.
int procCount = System.Environment.ProcessorCount;
// Data structure to hold names of subfolders to be
// examined for files.
Stack<string> dirs = new Stack<string>();
if (!System.IO.Directory.Exists(root))
{
throw new ArgumentException();
}
dirs.Push(root);
while (dirs.Count > 0)
{
string currentDir = dirs.Pop();
string[] subDirs = null;
string[] files = null;
try
{
subDirs = System.IO.Directory.GetDirectories(currentDir);
}
// An UnauthorizedAccessException exception will be thrown if we do not have
// discovery permission on a folder or file. It may or may not be acceptable
// to ignore the exception and continue enumerating the remaining files and
// folders. It is also possible (but unlikely) that a DirectoryNotFound exception
// will be raised. This will happen if currentDir has been deleted by
// another application or thread after our call to Directory.Exists. The
// choice of which exceptions to catch depends entirely on the specific task
// you are intending to perform and also on how much you know with certainty
// about the systems on which this code will run.
catch (UnauthorizedAccessException e)
{
Console.WriteLine(e.Message);
continue;
}
catch (System.IO.DirectoryNotFoundException e)
{
Console.WriteLine(e.Message);
continue;
}
try
{
files = System.IO.Directory.GetFiles(currentDir);
}
catch (UnauthorizedAccessException e)
{
Console.WriteLine(e.Message);
continue;
}
catch (System.IO.DirectoryNotFoundException e)
{
Console.WriteLine(e.Message);
continue;
}
// Perform the required action on each file here in parallel
// if there are a sufficient number of files in the directory
// or else sequentially if not. Files are opened and processed
// synchronously but this could be modified to perform async I/O.
try
{
if (files.Length < procCount)
{
foreach (var file in files)
{
action(file);
fileCount++;
}
}
else
{
Parallel.ForEach(files, () => 0, (file, loopState, localCount) =>
{
action(file);
return (int) ++localCount;
},
(c) =>
{
Interlocked.Exchange(ref fileCount, fileCount + c);
});
}
}
catch (AggregateException ae)
{
ae.Handle((ex) =>
{
if (ex is UnauthorizedAccessException)
{
// Here we just output a message and go on.
Console.WriteLine(ex.Message);
return true;
}
// Handle other exceptions here if necessary...
return false;
});
}
// Push the subdirectories onto the stack for traversal.
// This could also be done before handing the files.
foreach (string str in subDirs)
dirs.Push(str);
}
// For diagnostic purposes.
Console.WriteLine("Processed {0} files in {1} milleseconds", fileCount, sw.ElapsedMilliseconds);
}
}
}
Dans cet exemple, les E/S des fichiers sont exécutées en mode synchrone. Si le nombre de fichiers est élevé ou si les connexions réseau sont lentes, il peut être préférable d'accéder aux fichiers en mode asynchrone. Vous pouvez combiner les techniques d'E/S asynchrones avec l'itération parallèle. Pour plus d'informations, consultez Bibliothèque parallèle de tâches et programmation asynchrone .NET traditionnelle.
Notez que si une exception est levée dans le thread principal, l'exécution des threads démarrés par la méthode ForEach peut continuer. Pour arrêter ces threads, vous pouvez définir une variable booléenne dans vos gestionnaires d'exceptions et vérifier sa valeur pour chaque itération de la boucle parallèle. Si la valeur indique qu'une exception a été levée, utilisez la variable ParallelLoopState pour arrêter ou quitter la boucle. Pour plus d'informations, consultez Comment : arrêter ou quitter une boucle Parallel.For.