Начинающий - C# итерация по каталогу для создания списка файлов

Question

Конечная цель состоит в том, чтобы иметь некоторую форму структуры данных, которая хранит иерархическую структуру каталога, который будет сохранен в текстовом файле.

Я использую следующий код и до сих пор, и я борюсь с объединением директорий, субдиректорий и файлов.

/// <summary>
/// code based on http://msdn.microsoft.com/en-us/library/bb513869.aspx
/// </summary>
/// <param name="strFolder"></param>
public static void TraverseTree ( string strFolder )
{
  // Data structure to hold names of subfolders to be
  // examined for files.
  Stack<string> dirs = new Stack<string>( 20 );

  if ( !System.IO.Directory.Exists( strFolder ) )
  {
    throw new ArgumentException();
  }
  dirs.Push( strFolder );

  while ( dirs.Count > 0 )
  {
    string currentDir = dirs.Pop();
    string[] subDirs;
    try
    {
      subDirs = System.IO.Directory.GetDirectories( currentDir );
    }

    catch ( UnauthorizedAccessException e )
    {
      MessageBox.Show( "Error: " + e.Message );
      continue;
    }
    catch ( System.IO.DirectoryNotFoundException e )
    {
      MessageBox.Show( "Error: " +  e.Message );
      continue;
    }

    string[] files = null;
    try
    {
      files = System.IO.Directory.GetFiles( currentDir );
    }

    catch ( UnauthorizedAccessException e )
    {
      MessageBox.Show( "Error: " +  e.Message );
      continue;
    }

    catch ( System.IO.DirectoryNotFoundException e )
    {
      MessageBox.Show( "Error: " + e.Message );
      continue;
    }
    // Perform the required action on each file here.
    // Modify this block to perform your required task.
    /*
    foreach ( string file in files )
    {
      try
      {
        // Perform whatever action is required in your scenario.
        System.IO.FileInfo fi = new System.IO.FileInfo( file );
        Console.WriteLine( "{0}: {1}, {2}", fi.Name, fi.Length, fi.CreationTime );
      }
      catch ( System.IO.FileNotFoundException e )
      {
        // If file was deleted by a separate application
        //  or thread since the call to TraverseTree()
        // then just continue.
        MessageBox.Show( "Error: " +  e.Message );
        continue;
      }
    } 
    */

    // 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 );

    foreach ( string str in files )
      MessageBox.Show( str );
  }

Answer 1

Я получил его работать с помощью кода на основе http://weblogs.asp.net/israelio/archive/2004/06/23/162913.aspx

// How much deep to scan. (of course you can also pass it to the method)
const int HowDeepToScan=20;

public static void ProcessDir ( string dirName, int recursionLvl, string strFileName)
{

  string tabs = new String( '-', recursionLvl );

  if ( recursionLvl<=HowDeepToScan )
  {
    // Process the list of files found in the directory. 
    string [] fileEntries = Directory.GetFiles( dirName );
    TextWriter tw = new StreamWriter( strFileName, true );
    tw.WriteLine( tabs + "<a href=\" " +  System.IO.Path.GetFullPath( dirName ) + "\">" + System.IO.Path.GetFileName( dirName ) + "</a><br />" );
    foreach ( string fileName in fileEntries )
    {
      // do something with fileName

      tw.WriteLine( tabs + "<a href=\" " +  System.IO.Path.GetFullPath( fileName ) + "\">" + System.IO.Path.GetFileName( fileName ) + "</a><br />" );

    }
    tw.Close();

    // Recurse into subdirectories of this directory.
    string [] subdirEntries = Directory.GetDirectories( dirName );
    foreach ( string subdir in subdirEntries )
      // Do not iterate through reparse points
      if ( ( File.GetAttributes( subdir ) &
        FileAttributes.ReparsePoint ) !=
            FileAttributes.ReparsePoint )

        ProcessDir( subdir, recursionLvl+1, strFileName );

  }
}

выход

<a href=" C:\code">code</a><br />
<a href=" C:\code\group.zip">FluentPath (1).zip</a><br />
<a href=" C:\code\index.html">index.html</a><br />

Answer 2

Вы можете использовать своего рода составной шаблон, где составной элемент - это папка.

Вот пример кода, который строит древовидную структуру целевой папки. Он работает рекурсивно и потребляет немного больше памяти, но простота того стоит.

class TreeItem
{
    public string FolderName;
    public List<TreeItem> SubFolders = new List<TreeItem>();
    public string[] Files;
}

class Program
{

    private static TreeItem FileTree(string rootFolder){
        var item = new TreeItem();
        item.FolderName = rootFolder;
        item.Files = System.IO.Directory.GetFiles(rootFolder);

        foreach(var folder in System.IO.Directory.GetDirectories(rootFolder))
        {
            item.SubFolders.Add(FileTree(folder));
        }
        return item;
    }

    //Traversal algorithm
    private static void PrintComposite(TreeItem node, int ident)
    {
        var dirName = System.IO.Path.GetFileName(node.FolderName);
        Console.WriteLine(@"{0}{1}", new string('-', ident), dirName);
        foreach(var subNode in node.SubFolders)
        {
            PrintComposite(subNode, ident + 1);
        }
    }

    public static void Main(string[] args)
    {
        var tree = FileTree(@"D:\Games");
        PrintComposite(tree,0);
    }   
}

Answer 3

Во-первых, я думаю, вам нужно сделать больше объектов. Интерфейс DirectoryElementInterface или абстрактный класс и объект DirectoryElement, а также объект FileElement, который реализует DirectoryElementInterface. Теперь вместо использования стека для перебора иерархии создайте DirectoryElementInterface root = new DirectoryElement(nameOfNode), Затем для каждого файла в getFiles сделать что-то вроде root.addElement(new FileElement(filename));, addElement должен добавить в список внутри DirectoryElement. Сделайте аналогично для каталогов. Хорошо, теперь вы можете создать один уровень.

Теперь для шага итерации. Возьми рутину, которую ты только что написал, и сделай root параметр. Вы можете назвать это как угодно, но для этого обсуждения я буду называть эту новую подпрограмму addDirectoryInformation. Теперь вашим главным будет создание корня и вызов addDirectoryInformation, передаваемый в корне. Чтобы выполнить итерацию, нам нужно запросить у заполненного корня список его элементов, выполнить foreach над списком и вызвать addDirectoryInformation для каждого элемента, являющегося каталогом. Как только у вас это заработает, переместите цикл в конец addDirectoryInformation. Теперь каждый добавляемый вами каталог рекурсивно добавляет все свои дочерние элементы.

Еще одна вещь для правильной рекурсивной программы. Вы должны знать, когда прекратить повторение. В этом случае это легко. Если в списке нет каталогов, addDirectoryInformation никогда не вызывается. Итак, вы сделали.

Answer 4

На прошлой неделе я проводил курс, где мы делали что-то похожее, вывод был консольным, но нет причин, по которым вы не можете записать это в файл.txt.

используя Систему; using System.Collections.Generic; использование System.Linq; использование System.Text;

пространство имен ShowDirectory {класс Program { static void Main(string[] args) { Console.WriteLine("Эта программа выводит список всех файлов в каталоге."); System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(@"C:\"); foreach (файл System.IO.FileInfo в dir.GetFiles (".")) {Console.WriteLine ("{0}, {1}", file.Name, file.Length); } Console.ReadLine (); }}}

Answer 5

Один из подходов состоит в том, чтобы использовать итератор для дерева файлов следующим образом:

// IncludeExcludeFileEnumerator(string baseDir, string includePattern, string excludePattern)
// Include pattern can include ** that means tree hierarchy
var myFiles = new IncludeExcludeFileEnumerable(@"C:\test\aaa", @"**.bmp,*.jpg", "*excl_bad*.*,*fu*");
foreach (var s in myFiles)
{
    Console.Out.WriteLine(s);
}

Код для файлового итератора ( IEnumerator, IEnumerable):

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;

namespace IncludeExcludeFileEnumerator
{
    public class IncludeExcludeFileEnumerator : IEnumerator<String>
    {
        private string excludeRegExPattern;
        private readonly Regex regexSeparateFilePath;
        private readonly Regex excludeRegex = null;
        private int currentPatternIndex;
        private IEnumerator<string> filesEnum;
        private IEnumerable<string> files;
        bool isNext = true;
        private readonly List<Tuple<string, string, SearchOption>> incPatternsList;


        public IncludeExcludeFileEnumerator(string baseDirectory, string includePattern, string excludePattern)
        {
            // Split comma separated string to array of include patterns
            var initIncludePatterns = includePattern.Split(',');
            regexSeparateFilePath = new Regex(@"(.*)[\\/]([^\\/]*$)", RegexOptions.Compiled);

            // Prepare include patterns
            incPatternsList = initIncludePatterns.ToList().ConvertAll(
                (incPattern) =>
                {
                    incPattern = incPattern.Trim();
                    var matches = regexSeparateFilePath.Matches(incPattern);
                    string pathPattern;
                    string filePattern;
                    if (matches.Count == 0)
                    {
                        pathPattern = "";
                        filePattern = incPattern;
                    }
                    else
                    {
                        pathPattern = matches[0].Groups[1].Value;
                        filePattern = matches[0].Groups[2].Value;
                    }
                    SearchOption searchOption = SearchOption.TopDirectoryOnly;
                    if (filePattern.Contains("**"))
                    {
                        filePattern = filePattern.Replace("**", "*");
                        searchOption = SearchOption.AllDirectories;
                    }
                    var fullPathPattern = Path.Combine(baseDirectory, pathPattern);
                    // Returns tuple {PathPattern, FilePattern, SearchOption}
                    return new Tuple<string, string, SearchOption>(fullPathPattern, filePattern, searchOption);
                });

            // Prepare regular expression for exclude case (all in one, concatinated by (| - or) separator)
            if (!String.IsNullOrWhiteSpace(excludePattern))
            {
                var excPatterns = excludePattern.Replace(".", @"\.");
                excPatterns = excPatterns.Replace("*", ".*");
                excludeRegExPattern = excPatterns.Replace(",", "|");
                excludeRegex = new Regex(excludeRegExPattern, RegexOptions.Compiled);
            }
            Reset();
        }

        public string Current
        {
            get { return filesEnum.Current; }
        }

        public void Dispose()
        {

        }

        object System.Collections.IEnumerator.Current
        {
            get { return (Object)this.Current; }
        }

        public bool MoveNext()
        {
            do
            {
                if (( filesEnum == null ) && (incPatternsList.Count < currentPatternIndex + 2))
                {
                    return false;
                }
                if ((filesEnum == null) || (isNext == false))
                {
                    var tuple = incPatternsList[++currentPatternIndex];
                    files = Directory.EnumerateFiles(tuple.Item1, tuple.Item2, tuple.Item3);
                    filesEnum = files.GetEnumerator();
                    isNext = true;
                }
                while (isNext)
                {
                    isNext = filesEnum.MoveNext();
                    if (isNext) 
                    {
                        if (excludeRegex==null) return true;
                        if (!excludeRegex.Match(filesEnum.Current).Success) return true;
                        // else continue;
                    }
                    else
                    {
                        filesEnum = null;
                    }
                }
            } while (true);
        }

        public void Reset()
        {
            currentPatternIndex = -1;
            filesEnum = null;
        }
    }

    public class IncludeExcludeFileEnumerable : IEnumerable<string>
    {
        private string baseDirectory;
        private string includePattern;
        private string excludePattern;

        public IncludeExcludeFileEnumerable(string baseDirectory, string includePattern, string excludePattern)
        {
            this.baseDirectory = baseDirectory;
            this.includePattern = includePattern;
            this.excludePattern = excludePattern;
        }

        public IEnumerator<string> GetEnumerator()
        {
            return new IncludeExcludeFileEnumerator(baseDirectory, includePattern, excludePattern);
        }

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