cómo obtener el archivo más antiguo en un directorio rápido con .NET?

Question

Tengo un directorio con alrededor de 15-30 mil archivos. Necesito simplemente sacar el más viejo. En otras palabras, el que fue creado primero. ¿Hay una manera rápida de hacer esto usando C#, aparte de cargarlos en una colección y luego ordenarlos?

Answer 1

La respuesta corta es no. Los sistemas de archivos de Windows no indexan los archivos por fecha, por lo que no existe una forma nativa de hacerlo, y mucho menos un camino .net sin enumerarlos todos.

Answer 2

La clasificación es O(n log n). En cambio, ¿por qué no solo enumera el directorio? No estoy seguro de lo que el equivalente C# de FindFirstFile()/FindNextFile() es, pero quiero hacer es:

• mantener actualizada la fecha y el nombre más bajo en una variable local.

• Enumerar el directorio.

  • Si la fecha de un archivo determinado es menor que la variable local, establezca la variable local en la nueva fecha y nombre de archivo.

Answer 3

Si controlas el directorio (es decir, si sus programas son responsables de la creación y el mantenimiento de todos los archivos de ese directorio), entonces debería considerar el seguimiento de los metadatos acerca de cada archivo por separado; quizás en una base de datos.

De hecho, el tipo de columna FileStream en SQL Server 2008 puede ayudar con esto. Puede crear una tabla que contenga columnas para nombre de archivo, crear fecha, modificar fecha y una columna FileStream para el contenido. Puede encontrar cosas como el archivo más antiguo usando índices en las columnas de metadatos. Puede encontrar el contenido utilizando la columna FileStream.

Answer 4

Mira, ¿no sería más fácil de pagar a un proceso oculto y redirigir el flujo de salida a la entrada y el uso de la dir /o-d que clasifica por la fecha/hora, usando el tablero invierte la operación ....

Editar: aquí hay un código de ejemplo para hacer esto ... rápido y sucio ...

 
public class TestDir 
    { 
     private StringBuilder sbRedirectedOutput = new StringBuilder(); 
     public string OutputData 
     { 
      get { return this.sbRedirectedOutput.ToString(); } 
     } 
     public void Run() 
     { 
      System.Diagnostics.ProcessStartInfo ps = new System.Diagnostics.ProcessStartInfo(); 
      ps.FileName = "cmd"; 
      ps.ErrorDialog = false; 
      ps.Arguments = string.Format("dir {0} /o-d", path_name); 
      ps.CreateNoWindow = true; 
      ps.UseShellExecute = false; 
      ps.RedirectStandardOutput = true; 
      ps.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden; 

      using (System.Diagnostics.Process proc = new System.Diagnostics.Process()) 
      { 
       proc.StartInfo = ps; 
       proc.Exited += new EventHandler(proc_Exited); 
       proc.OutputDataReceived += new System.Diagnostics.DataReceivedEventHandler(proc_OutputDataReceived); 
       proc.Start(); 
       proc.WaitForExit(); 
       proc.BeginOutputReadLine(); 
       while (!proc.HasExited) ; 
      } 
     } 

     void proc_Exited(object sender, EventArgs e) 
     { 
      System.Diagnostics.Debug.WriteLine("proc_Exited: Process Ended"); 
     } 

     void proc_OutputDataReceived(object sender, System.Diagnostics.DataReceivedEventArgs e) 
     { 
      if (e.Data != null) this.sbRedirectedOutput.Append(e.Data + Environment.NewLine); 
      //System.Diagnostics.Debug.WriteLine("proc_OutputDataReceived: Data: " + e.Data); 
     } 
    } 

los primeros 4 o 5 líneas del objeto StringBuilder sbRedirectedOutput se pueden cortar a cabo, a continuación, después de que la línea contendría el nombre de archivo más antiguo y sería bastante fácil de analizar ...

Answer 5

Editar: Eliminó el género y lo convirtió en una función.

public static FileInfo GetOldestFile(string directory) 
{ 
    if (!Directory.Exists(directory)) 
     throw new ArgumentException(); 

    DirectoryInfo parent = new DirectoryInfo(directory); 
    FileInfo[] children = parent.GetFiles(); 
    if (children.Length == 0) 
     return null; 

    FileInfo oldest = children[0]; 
    foreach (var child in children.Skip(1)) 
    { 
     if (child.CreationTime < oldest.CreationTime) 
      oldest = child; 
    } 

    return oldest; 
} 

Answer 6

Aquí está una rutina de C# que puede hacer lo que quiera por el desove de una consola CMD ejecutar un dir /o:D en el directorio especificado y devolver el nombre del primer archivo encontrado.

 static string GetOldestFile(string dirName) 
     { 
      ProcessStartInfo si = new ProcessStartInfo("cmd.exe"); 
      si.RedirectStandardInput = true; 
      si.RedirectStandardOutput = true; 
      si.UseShellExecute = false; 
      Process p = Process.Start(si); 
      p.StandardInput.WriteLine(@"dir " + dirName + " /o:D"); 
      p.StandardInput.WriteLine(@"exit"); 
      string output = p.StandardOutput.ReadToEnd(); 
      string[] splitters = { Environment.NewLine }; 
      string[] lines = output.Split(splitters, StringSplitOptions.RemoveEmptyEntries); 
      // find first line with a valid date that does not have a <DIR> in it 
      DateTime result; 
      int i = 0; 
      while (i < lines.Length) 
      { 
       string[] tokens = lines[i].Split(' '); 
       if (DateTime.TryParse(tokens[0], out result)) 
       { 
        if (!lines[i].Contains("<DIR>")) 
        { 
         return tokens[tokens.Length - 1]; 
        } 
       } 
       i++; 
      } 

      return ""; 
     } 

Answer 7

Usted tendrá que cargar los objetos de FileInfo en una especie recogida &, pero es una sola línea:

FileSystemInfo fileInfo = new DirectoryInfo(directoryPath).GetFileSystemInfos() 
    .OrderByDescending(fi => fi.CreationTime).First(); 

Ok, dos líneas porque es una larga declaración.

Answer 8

No puede hacerlo sin ordenar, pero lo que puede hacer es hacerlo rápido.

La ordenación por CreationTime puede ser lenta porque el primer acceso a esta propiedad para cada archivo implica la interrogación del sistema de archivos.

Use A Faster Directory Enumerator que conserva más información sobre los archivos al enumerar y permite hacer la ordenación más rápido.

Código de comparar el rendimiento:

static void Main(string[] args) 
{ 
    var timer = Stopwatch.StartNew(); 

    var oldestFile = FastDirectoryEnumerator.EnumerateFiles(@"c:\windows\system32") 
     .OrderBy(f => f.CreationTime).First(); 

    timer.Stop(); 

    Console.WriteLine(oldestFile); 
    Console.WriteLine("FastDirectoryEnumerator - {0}ms", timer.ElapsedMilliseconds); 
    Console.WriteLine(); 

    timer.Reset(); 
    timer.Start(); 

    var oldestFile2 = new DirectoryInfo(@"c:\windows\system32").GetFiles() 
     .OrderBy(f => f.CreationTime).First(); 

    timer.Stop(); 

    Console.WriteLine(oldestFile2); 
    Console.WriteLine("DirectoryInfo - {0}ms", timer.ElapsedMilliseconds); 

    Console.WriteLine("Press ENTER to finish"); 
    Console.ReadLine(); 
} 

Para mí esto da:

VEN2232.OLB

FastDirectoryEnumerator - 27 ms

VEN2232.OLB

DirectoryInfo - 559m s

Answer 9

Por extraño que parezca, esto funcionó perfectamente en un directorio de la mía con 3000 + archivos jpg:

DirectoryInfo di = new DirectoryInfo(dpath); 
FileInfo[] rgFiles = di.GetFiles("*.jpg"); 
FileInfo firstfile = rgFiles[0]; 
FileInfo lastfile = rgFiles[rgFiles.Length - 1]; 
DateTime oldestfiletime = firstfile.CreationTime; 
DateTime newestfiletime = lastfile.CreationTime;