Búsqueda/análisis más rápido/seguro de archivos?

Question

En c:, tengo decenas de miles de archivos *.foobar. Están en todo tipo de lugares (es decir, subdirectorios). Estos archivos tienen aproximadamente 1 - 64 kb de tamaño y texto sin formato.

Tengo un class Foobar(string fileContents) que escribe fuertemente estos archivos .foobar.

Mi desafío es obtener una lista de todos los archivos *.foobar en c:, representados como una matriz de objetos Foobar. ¿Cuál es la forma más rápida de hacer esto?

Me interesa saber si hay una mejor manera (indudablemente) que mi primer enfoque, que sigue, y si este enfoque mío tiene algún problema potencial (por ejemplo, problemas de simultaneidad de E/S arrojando excepciones):

var files = Directory.EnumerateFiles 
       (rootPath, "*.foobar", SearchOption.AllDirectories); 

Foobar[] foobars = 
(
    from filePath in files.AsParallel() 
    let contents = File.ReadAllText(filePath) 
    select new Foobar(contents) 
) 
.ToArray(); 

Answer 1

Debido a errores de permiso (u otros errores) pueden parecer dejar a los muertos enumeración en sus pistas, es posible que desee implementar su propio encuestador algo como esto:

class SafeFileEnumerator : IEnumerable<string> 
{ 
    private string root; 
    private string pattern; 
    private IList<Exception> errors; 
    public SafeFileEnumerator(string root, string pattern) 
    { 
    this.root = root; 
    this.pattern = pattern; 
    this.errors = new List<Exception>(); 
    } 

    public SafeFileEnumerator(string root, string pattern, IList<Exception> errors) 
    { 
    this.root = root; 
    this.pattern = pattern; 
    this.errors = errors; 
    } 

    public Exception[] Errors() 
    { 
    return errors.ToArray(); 
    } 
    class Enumerator : IEnumerator<string> 
    { 
    IEnumerator<string> fileEnumerator; 
    IEnumerator<string> directoryEnumerator; 
    string root; 
    string pattern; 
    IList<Exception> errors; 

    public Enumerator(string root, string pattern, IList<Exception> errors) 
    { 
     this.root = root; 
     this.pattern = pattern; 
     this.errors = errors; 
     fileEnumerator = System.IO.Directory.EnumerateFiles(root, pattern).GetEnumerator(); 
     directoryEnumerator = System.IO.Directory.EnumerateDirectories(root).GetEnumerator(); 
    } 
    public string Current 
    { 
     get 
     { 
      if (fileEnumerator == null) throw new ObjectDisposedException("FileEnumerator"); 
      return fileEnumerator.Current; 
     } 
    } 

    public void Dispose() 
    { 
     if (fileEnumerator != null) 
      fileEnumerator.Dispose(); 
     fileEnumerator = null; 
     if (directoryEnumerator != null) 
      directoryEnumerator.Dispose(); 
     directoryEnumerator = null; 
    } 

    object System.Collections.IEnumerator.Current 
    { 
     get { return Current; } 
    } 

    public bool MoveNext() 
    { 
     if ((fileEnumerator != null) && (fileEnumerator.MoveNext())) 
      return true; 
     while ((directoryEnumerator != null) && (directoryEnumerator.MoveNext())) 
     { 
      if (fileEnumerator != null) 
       fileEnumerator.Dispose(); 
      try 
      { 
       fileEnumerator = new SafeFileEnumerator(directoryEnumerator.Current, pattern, errors).GetEnumerator(); 
      } 
      catch (Exception ex) 
      { 
       errors.Add(ex); 
       continue; 
      } 
      if (fileEnumerator.MoveNext()) 
       return true; 
     } 
     if (fileEnumerator != null) 
      fileEnumerator.Dispose(); 
     fileEnumerator = null; 
     if (directoryEnumerator != null) 
      directoryEnumerator.Dispose(); 
     directoryEnumerator = null; 
     return false; 
    } 

    public void Reset() 
    { 
     Dispose(); 
     fileEnumerator = System.IO.Directory.EnumerateFiles(root, pattern).GetEnumerator(); 
     directoryEnumerator = System.IO.Directory.EnumerateDirectories(root).GetEnumerator(); 
    } 
    } 
    public IEnumerator<string> GetEnumerator() 
    { 
    return new Enumerator(root, pattern, errors); 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
    return GetEnumerator(); 
    } 
} 

Answer 2

Gran trabajo, aquí es una extensión a su código para devolver FileSystemInfo en lugar de caminos de cuerda. Cambios menores en la línea, como agregar en SearchOption (como el .NET nativo que tiene) y captura de errores en el directorio inicial, en caso de que la carpeta raíz sea denegada. ¡Gracias de nuevo por la publicación original!

public class SafeFileEnumerator : IEnumerable<FileSystemInfo> 
{ 
    /// <summary> 
    /// Starting directory to search from 
    /// </summary> 
    private DirectoryInfo root; 

    /// <summary> 
    /// Filter pattern 
    /// </summary> 
    private string pattern; 

    /// <summary> 
    /// Indicator if search is recursive or not 
    /// </summary> 
    private SearchOption searchOption; 

    /// <summary> 
    /// Any errors captured 
    /// </summary> 
    private IList<Exception> errors; 

    /// <summary> 
    /// Create an Enumerator that will scan the file system, skipping directories where access is denied 
    /// </summary> 
    /// <param name="root">Starting Directory</param> 
    /// <param name="pattern">Filter pattern</param> 
    /// <param name="option">Recursive or not</param> 
    public SafeFileEnumerator(string root, string pattern, SearchOption option) 
     : this(new DirectoryInfo(root), pattern, option) 
    {} 

    /// <summary> 
    /// Create an Enumerator that will scan the file system, skipping directories where access is denied 
    /// </summary> 
    /// <param name="root">Starting Directory</param> 
    /// <param name="pattern">Filter pattern</param> 
    /// <param name="option">Recursive or not</param> 
    public SafeFileEnumerator(DirectoryInfo root, string pattern, SearchOption option) 
     : this(root, pattern, option, new List<Exception>()) 
    {} 

    // Internal constructor for recursive itterator 
    private SafeFileEnumerator(DirectoryInfo root, string pattern, SearchOption option, IList<Exception> errors) 
    { 
     if (root == null || !root.Exists) 
     { 
      throw new ArgumentException("Root directory is not set or does not exist.", "root"); 
     } 
     this.root = root; 
     this.searchOption = option; 
     this.pattern = String.IsNullOrEmpty(pattern) 
      ? "*" 
      : pattern; 
     this.errors = errors; 
    } 

    /// <summary> 
    /// Errors captured while parsing the file system. 
    /// </summary> 
    public Exception[] Errors 
    { 
     get 
     { 
      return errors.ToArray(); 
     } 
    } 

    /// <summary> 
    /// Helper class to enumerate the file system. 
    /// </summary> 
    private class Enumerator : IEnumerator<FileSystemInfo> 
    { 
     // Core enumerator that we will be walking though 
     private IEnumerator<FileSystemInfo> fileEnumerator; 
     // Directory enumerator to capture access errors 
     private IEnumerator<DirectoryInfo> directoryEnumerator; 

     private DirectoryInfo root; 
     private string pattern; 
     private SearchOption searchOption; 
     private IList<Exception> errors; 

     public Enumerator(DirectoryInfo root, string pattern, SearchOption option, IList<Exception> errors) 
     { 
      this.root = root; 
      this.pattern = pattern; 
      this.errors = errors; 
      this.searchOption = option; 

      Reset(); 
     } 

     /// <summary> 
     /// Current item the primary itterator is pointing to 
     /// </summary> 
     public FileSystemInfo Current 
     { 
      get 
      { 
       //if (fileEnumerator == null) throw new ObjectDisposedException("FileEnumerator"); 
       return fileEnumerator.Current as FileSystemInfo; 
      } 
     } 

     object System.Collections.IEnumerator.Current 
     { 
      get { return Current; } 
     } 

     public void Dispose() 
     { 
      Dispose(true, true); 
     } 

     private void Dispose(bool file, bool dir) 
     { 
      if (file) 
      { 
       if (fileEnumerator != null) 
        fileEnumerator.Dispose(); 

       fileEnumerator = null; 
      } 

      if (dir) 
      { 
       if (directoryEnumerator != null) 
        directoryEnumerator.Dispose(); 

       directoryEnumerator = null; 
      } 
     } 

     public bool MoveNext() 
     { 
      // Enumerate the files in the current folder 
      if ((fileEnumerator != null) && (fileEnumerator.MoveNext())) 
       return true; 

      // Don't go recursive... 
      if (searchOption == SearchOption.TopDirectoryOnly) { return false; } 

      while ((directoryEnumerator != null) && (directoryEnumerator.MoveNext())) 
      { 
       Dispose(true, false); 

       try 
       { 
        fileEnumerator = new SafeFileEnumerator(
         directoryEnumerator.Current, 
         pattern, 
         SearchOption.AllDirectories, 
         errors 
         ).GetEnumerator(); 
       } 
       catch (Exception ex) 
       { 
        errors.Add(ex); 
        continue; 
       } 

       // Open up the current folder file enumerator 
       if (fileEnumerator.MoveNext()) 
        return true; 
      } 

      Dispose(true, true); 

      return false; 
     } 

     public void Reset() 
     { 
      Dispose(true,true); 

      // Safely get the enumerators, including in the case where the root is not accessable 
      if (root != null) 
      { 
       try 
       { 
        fileEnumerator = root.GetFileSystemInfos(pattern, SearchOption.TopDirectoryOnly).AsEnumerable<FileSystemInfo>().GetEnumerator(); 
       } 
       catch (Exception ex) 
       { 
        errors.Add(ex); 
        fileEnumerator = null; 
       } 

       try 
       { 
        directoryEnumerator = root.GetDirectories(pattern, SearchOption.TopDirectoryOnly).AsEnumerable<DirectoryInfo>().GetEnumerator(); 
       } 
       catch (Exception ex) 
       { 
        errors.Add(ex); 
        directoryEnumerator = null; 
       } 
      } 
     } 
    } 
    public IEnumerator<FileSystemInfo> GetEnumerator() 
    { 
     return new Enumerator(root, pattern, searchOption, errors); 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 
}