Come limitare la profondità di un ricorsivo sottodirectory Ricerca

Question

Ho una funzione che attualmente prende tutte le cartelle e sottocartelle per controllare l'ACL di un piccolo strumento che sto costruendo, ma sto tirando fuori i miei capelli cercando di capire come limitare la profondità a cui può andare. Ad esempio hai una cartella che ha 4 livelli di profondità ma voglio essere in grado di prenderne solo 3 livelli per ACL.

Attualmente l'ho codificato questa convenzione:

private void StepThroughDirectories(string dir) 
{ 
    string[] directories = Directory.GetDirectories(dir); 
    try 
    { 
     foreach (string d in Directory.GetDirectories(dir)) 
     { 
      if (recCount < (int)Depth) 
      { 
       GetACLs(d, new DirectoryInfo(d)); 
       pBar.Value += 1; 
       //MessageBox.Show("Recursive Level: " + counter.ToString()); 
       recCount++; 
       StepThroughDirectories(d); 
      } 
      else 
      { 
       recCount--; 
      } 
     } 
    } 
    catch (System.Exception e) 
    { 
     Console.WriteLine(e.Message); 
    } 
} 

Ovviamente questo non è bello come è stato perché ho lavorato sul problema per un po ', ma se qualcuno mi può puntare nella giusta direzione per risolvere questo problema sarei molto felice!

Answer 1

In primo luogo, evitare di dichiarare il campo recCount esterno come una variabile “globale”. Negli scenari ricorsivi è solitamente più gestibile passare lo stato lungo le chiamate ricorsive.

In secondo luogo, spostare il test di profondità su foreach per rimuovere query non necessarie del file system per le sottodirectory.

In terzo luogo, inserire la logica di elaborazione effettiva all'inizio del tuo metodo, ancora una volta fuori dal giro di elaborazione sottodirectory.

Il tuo codice sarebbe quindi simile:

void StepThroughDirectories(string dir) 
{ 
    StepThroughDirectories(dir, 0) 
} 

void StepThroughDirectories(string dir, int currentDepth) 
{ 
    // process 'dir' 
    ... 

    // process subdirectories 
    if (currentDepth < MaximumDepth) 
    { 
     foreach (string subdir in Directory.GetDirectories(dir)) 
      StepThroughDirectories(subdir, currentDepth + 1); 
    } 
} 

Answer 2

Un possibile metodo, aggiungere un campo di classe di fuori del metodo e una variabile per indicare quanti livelli di profondità per andare max.

livelli INT;

private void StepThroughDirectories(string dir, int depth) 
{ 
    levels ++; 
    if (levels > depth) 
     return; 
    string[] directories = Directory.GetDirectories(dir); 
    try 
    { ... 

Answer 3

Decremento RECCOUNT quando si torna dal StepThroughDirectories, ma questo sarebbe meglio ...

private void StepThroughDirectories(string dir, int depth) 
    { 
     if (depth < 0) 
      return; 
     string[] directories = Directory.GetDirectories(dir); 
     try 
     { 
      foreach (string d in Directory.GetDirectories(dir)) 
      { 
       // your code here 
       Console.WriteLine("{0}", d); 
       StepThroughDirectories(d, depth-1); 
      } 
     } 
     catch (System.Exception e) 
     { 
      Console.WriteLine(e.Message); 
     } 
    }