Répertoire.EnumerateFiles => UnauthorizedAccessException

Ths question avec la réponse ci-dessus est qu'elle ne fait pas prendre soin d'exception dans les sous répertoires. Ce serait une meilleure façon de gérer les exceptions de sorte que vous obtenez TOUS les fichiers de TOUS les sous-répertoires à l'exception de ceux ayant jeté un accès exception:

    ///<summary>
    ///A safe way to get all the files in a directory and sub directory without crashing on UnauthorizedException or PathTooLongException
    ///</summary>
    ///<param name="rootPath">Starting directory</param>
    ///<param name="patternMatch">Filename pattern match</param>
    ///<param name="searchOption">Search subdirectories or only top level directory for files</param>
    ///<returns>List of files</returns>
    public static IEnumerable<string> GetDirectoryFiles(string rootPath, string patternMatch, SearchOption searchOption)
    {
        var foundFiles = Enumerable.Empty<string>();

        if (searchOption == SearchOption.AllDirectories)
        {
            try
            {
                IEnumerable<string> subDirs = Directory.EnumerateDirectories(rootPath);
                foreach (string dir in subDirs)
                {
                    foundFiles = foundFiles.Concat(GetDirectoryFiles(dir, patternMatch, searchOption)); //Add files in subdirectories recursively to the list
                }
            }
            catch (UnauthorizedAccessException) { }
            catch (PathTooLongException) {}
        }

        try
        {
            foundFiles = foundFiles.Concat(Directory.EnumerateFiles(rootPath, patternMatch)); //Add files from the current directory
        }
        catch (UnauthorizedAccessException) { }

        return foundFiles;
    }

Je comprends que c'est MoveNext qui lève l'exception.

J'ai essayé d'écrire une méthode sûre pour des marches d'une séquence et tente d'ignorer MoveNext exceptions. Cependant, je ne suis pas sûr si MoveNext progrès de la position quand elle lève une exception, donc cela pourrait aussi bien être une boucle infinie. C'est aussi une mauvaise idée, parce que nous nous appuyons sur les détails d'implémentation.

Mais c'est juste tellement amusant!

public static IEnumerable<T> SafeWalk<T> (this IEnumerable<T> source)
{
    var enumerator = source.GetEnumerator();
    bool? hasCurrent = null;

    do {
        try {
            hasCurrent = enumerator.MoveNext();
        } catch {
            hasCurrent = null; //we're not sure
        }

        if (hasCurrent ?? false) //if not sure, do not return value
            yield return enumerator.Current;

    } while (hasCurrent ?? true); //if not sure, continue walking
}

foreach (var file in Directory.EnumerateFiles("c:\\", "*", SearchOption.AllDirectories)
                              .SafeWalk())
{
    //...
}

Cela ne fonctionnera que si les conditions suivantes sont vraies à propos du cadre de mise en œuvre de cet itérateur (voir FileSystemEnumerableIterator<TSource> Réflecteur de référence):

• MoveNext progrès de sa position lorsqu'il échoue;
• Quand MoveNext échoue sur le dernier élément, les appels suivants seront de retour false au lieu de lancer une exception;
• Ce comportement est cohérent pour les différentes versions de .NET Framework;
• Je n'ai pas fait toute la logique ou les erreurs de syntaxe.

Même si elle travaille, s'il vous plaît, ne l'utilisez jamais dans de production!

Mais je me demande vraiment si il n'.

Basé sur strudso réponse, mais que les méthodes d'extension pour les deux FileInfo et DirectoryInfo.

public static IEnumerable<FileInfo> EnumerateFilesSafe(this DirectoryInfo dir, string filter = "*.*", SearchOption opt = SearchOption.TopDirectoryOnly)
{
    var retval = Enumerable.Empty<FileInfo>();

    try { retval = dir.EnumerateFiles(filter); }
    catch { Debug.WriteLine("{0} Inaccessable.", dir.FullName); }

    if (opt == SearchOption.AllDirectories)
        retval = retval.Concat(dir.EnumerateDirectoriesSafe(opt: opt).SelectMany(x => x.EnumerateFilesSafe(filter, opt)));

    return retval;
}

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesSafe(this DirectoryInfo dir, string filter = "*.*", SearchOption opt = SearchOption.TopDirectoryOnly)
{
    var retval = Enumerable.Empty<DirectoryInfo>();

    try { retval = dir.EnumerateDirectories(filter); }
    catch { Debug.WriteLine("{0} Inaccessable.", dir.FullName); }

    if (opt == SearchOption.AllDirectories)
        retval = retval.Concat(retval.SelectMany(x => x.EnumerateDirectoriesSafe(filter, opt)));

    return retval;
}