如何在列表中存储子目录c#

Question

the below code will display all sub-directories contained in the main directory
i need to get the data displayed by method LoadSubDirs(string dir) stored in a list

class Program
{

    static void Main(string[] args)
    {
        string root = @"D:\";
        string[] subdirectories = Directory.GetDirectories(root);

        foreach (string subdir in subdirectories)
        {
            LoadSubDirs(subdir);


        }

    }
    private static void LoadSubDirs(string dir)
    {
        Console.WriteLine(dir);

        try
        {
            string[] subdirectories = Directory.GetDirectories(dir);

            foreach (string subdir in subdirectories)
            {
                try
                {
                    LoadSubDirs(subdir);
                }
                catch { }


            }
        }
    }
}

Answer 1

This is your code, with the directory saved in a List object

using System.IO;
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        string root = @"D:\";
        string[] subdirectories = Directory.GetDirectories(root);
        List<string> listDirs = new List<string>();

        foreach (string subdir in subdirectories)
        {
            LoadSubDirs(subdir, listDirs);
        }

    }
    private static void LoadSubDirs(string dir, List<string> listDirs)
    {
        Console.WriteLine(dir);
        listDirs.Add(dir);

        try
        {
            string[] subdirectories = Directory.GetDirectories(dir);

            foreach (string subdir in subdirectories)
            {
                try
                {
                    LoadSubDirs(subdir, listDirs);
                }
                catch { }
            }
        }
    }
}

Answer 2

If your goal is to use properly recursivity, I think you should do like that. In my opinion if you "loop" a first time before calling your recursive function you're missing something. And if you're using a class/struct like FolderStruct here, you keep the "tree", wich can be useful sometimes.

   public class FolderStruct
{
    public string FolderName { get; set; }
    public List<FolderStruct> FolderChildren { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        FolderStruct FolderTree = new FolderStruct
        {
            FolderName = @"D:\",
            FolderChildren = new List<FolderStruct>()
        };
        LoadSubDirs(FolderTree);
        Console.ReadKey();
    }

    private static FolderStruct LoadSubDirs(FolderStruct FolderTree)
    {
        try
        {
            string[] subdirectories = Directory.GetDirectories(FolderTree.FolderName);
            if (subdirectories != null)
            {
                foreach (string subdir in subdirectories)
                {
                    var newFolder = new FolderStruct()
                    {
                        FolderName = subdir,
                        FolderChildren = new List<FolderStruct>()
                    };
                    var ret = LoadSubDirs(newFolder);
                    if (ret != null)
                        FolderTree.FolderChildren.Add(ret);
                }
                return FolderTree;
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
            return null;
        }
        return null;
    }
}

Answer 3

See sample code below :

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

namespace SAveDirectoriesXml
{
    class Program
    {
        const string FILENAME = @"c:\temp\test.xml";
        const string FOLDER = @"c:\temp";
        static XmlWriter writer = null;
        static void Main(string[] args)
        {
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;

            writer = XmlWriter.Create(FILENAME, settings);
            writer.WriteStartDocument(true);

            DirectoryInfo info = new DirectoryInfo(FOLDER);
            WriteTree(info);

            writer.WriteEndDocument();
            writer.Flush();
            writer.Close();
            Console.WriteLine("Enter Return");
            Console.ReadLine();

        }
        static long WriteTree(DirectoryInfo info)
        {
            long size = 0;
            writer.WriteStartElement("Folder");
            try
            {
                writer.WriteAttributeString("name", info.Name);
                writer.WriteAttributeString("numberSubFolders", info.GetDirectories().Count().ToString());
                writer.WriteAttributeString("numberFiles", info.GetFiles().Count().ToString());
                writer.WriteAttributeString("date", info.LastWriteTime.ToString());


                foreach (DirectoryInfo childInfo in info.GetDirectories())
                {
                    size += WriteTree(childInfo);
                }

            }
            catch (Exception ex)
            {
                string errorMsg = string.Format("Exception Folder : {0}, Error : {1}", info.FullName, ex.Message);
                Console.WriteLine(errorMsg);
                writer.WriteElementString("Error", errorMsg);
            }

            FileInfo[] fileInfo = null;
            try
            {
                fileInfo = info.GetFiles();
            }
            catch (Exception ex)
            {
                string errorMsg = string.Format("Exception FileInfo : {0}, Error : {1}", info.FullName, ex.Message);
                Console.WriteLine(errorMsg);
                writer.WriteElementString("Error",errorMsg);
            }

            if (fileInfo != null)
            {
                foreach (FileInfo finfo in fileInfo)
                {
                    try
                    {
                        writer.WriteStartElement("File");
                        writer.WriteAttributeString("name", finfo.Name);
                        writer.WriteAttributeString("size", finfo.Length.ToString());
                        writer.WriteAttributeString("date", info.LastWriteTime.ToString());
                        writer.WriteEndElement();
                        size += finfo.Length;
                    }
                    catch (Exception ex)
                    {
                        string errorMsg = string.Format("Exception File : {0}, Error : {1}", finfo.FullName, ex.Message);
                        Console.WriteLine(errorMsg);
                        writer.WriteElementString("Error", errorMsg);
                    }
                }
            }

            writer.WriteElementString("size", size.ToString());
            writer.WriteEndElement();
            return size;

        }
    }
}

Answer 4

I'm not sure if I've totally overlooked the requirement, but it seems like you are trying to get a list of all sub-directories from root and stored them in a List<string> .

This code will achieve exactly that without any additional methods or headache:

static void Main(string[] args)
{
    string root = @"D:\";
    List<string> listDirs = Directory.GetDirectories(root, "*.*", SearchOption.AllDirectories).ToList();
}

Using Directory.GetDirectories with the SearchOption.AllDirectories parameter will automatically return all sub-directories as an array of string .

Given that you want it as a List<string> , use .ToList() from Linq to convert the string array to the list. Remember to add using System.Linq to your imports.

Answer 5

  static void Main(string[] args)
    {
        string root = @"D:\";
        List<string> list= Recursive(root);

        foreach (string l in list)
        {
            Console.WriteLine(l);
        }

    }

      static IEnumerable<string> Recursive(string root )
    {

          string[] subdirectories = Directory.GetDirectories(root);
          yield return root;
          if(subdirectories !=null && subdirectories.Length>0)
          {
              foreach(var sub in subdirectories)
              {
                 foreach(var subsub in  Recursive(sub))
                 yield return subsub;
              }   
          }
          else
          {
             yield break;
          }
    }