एक निर्देशिका + उपनिर्देशिका में सभी फाइलों और निर्देशिकाओं को सूचीबद्ध करें

Question

मैं उस निर्देशिका की एक निर्देशिका और उपनिर्देशिका में निहित हर फ़ाइल और निर्देशिका को सूचीबद्ध करना चाहता हूं। यदि मैंने निर्देशिका के रूप में C: \ चुना है, तो प्रोग्राम को हार्ड ड्राइव पर हर फ़ाइल और फ़ोल्डर का हर नाम मिलेगा जिसे उसने एक्सेस किया था।

एक सूची की तरह लग सकता है

fd \ 1.txt
fd \ 2.txt
fd \ एक \
fd \ b \
fd \ एक \ 1.txt
fd \ एक \ 2.txt
fd \ एक \ एक \
fd \ एक \ b \
fd \ b \ 1.txt
fd \ b \ 2.txt
fd \ b \ एक
fd \ b \ b
fd \ एक \ एक \ 1.txt
fd \ एक \ एक \ एक \
fd \ एक \ b \ 1.txt
fd \ एक \ b \ एक
fd \ b \ एक \ 1.txt
fd \ b \ एक \ एक \
fd \ b \ b \ 1.txt
fd \ b \ b \ एक

Comments

वर्गों और विधियों के लिए System.IO नामस्थान ब्राउज़ करें जो आपकी सहायता कर सकते हैं।

— लूसेरो

की जाँच करें इस सवाल का , और हिस्सा है जहाँ वह एक पैटर्न मिलान है ड्रॉप।

— dasblinkenlight

डुप्लिकेट के संभावित डुप्लिकेट को C # में निर्देशिका की सभी फाइलों को कैसे सूचीबद्ध किया जाए?

— जोशविर्स

Answer 1

string[] allfiles = Directory.GetFiles("path/to/dir", "*.*", SearchOption.AllDirectories);

*.*फ़ाइलों से मिलान करने के लिए पैटर्न कहां है

यदि निर्देशिका भी आवश्यक है तो आप इस तरह से जा सकते हैं:

 foreach (var file in allfiles){
     FileInfo info = new FileInfo(file);
 // Do something with the Folder or just add them to a list via nameoflist.add();
 }

Comments

वास्तव में काम नहीं करेगा ... Lsit<>वर्ग? GetFiles क्या लौटाता है? और निर्देशिका नामों के बारे में क्या अनुरोध किया गया था?

— लुसिरो

GetFilesविधि एक स्ट्रिंग सरणी देता है।

— गुफ़ा

वास्तविक ... आप सही कह रहे हैं ... मैं 2 दिन पहले Qt abaout सीख रहा हूं और थोड़ा गलत था

— रुस्लान एफ।

यह काम कर सकता है, लेकिन यह अक्सर अनधिकृत असफलता के साथ विफल होता है। केवल निर्देशिका ही कैसे खोज सकती है?

— derp_in_mouth

इसका मतलब है कि आपके सिस्टम में इस ऐप को पर्याप्त अनुमति नहीं मिली है

— Ruslan F.

Answer 2

Directory.GetFileSystemEntries.NET 4.0+ में मौजूद है और फाइल और निर्देशिका दोनों को लौटाता है। इसे ऐसे कॉल करें:

string[] entries = Directory.GetFileSystemEntries(path, "*", SearchOption.AllDirectories);

ध्यान दें कि यह उन उपनिर्देशिकाओं की सामग्रियों को सूचीबद्ध करने के प्रयासों का सामना नहीं करेगा जिनकी आपके पास (अनधिकृत असफलता) तक पहुंच नहीं है, लेकिन यह आपकी आवश्यकताओं के लिए पर्याप्त हो सकता है।

Comments

यह अब तक का सबसे अच्छा उत्तर है। यह सभी फ़ाइलों और फ़ोल्डरों को कोड की एक पंक्ति में मिलता है, जो अन्य कोई भी नहीं करता है।

— स्टीव स्मिथ

Answer 3

फ़ोल्डर्स और फ़ाइलों को प्राप्त करने के लिए विधियों GetDirectoriesऔर GetFilesतरीकों का उपयोग करें ।

सबफ़ोल्डर्स में भी फ़ोल्डर्स और फ़ाइलों को प्राप्त करने के लिए उपयोग करें ।SearchOption AllDirectories

Comments

नाम के बाएं भाग को काटने के लिए सबस्ट्रिंग का उपयोग करें । :)

— लूसेरो

@ ल्यूकोरो आप ऐसा क्यों और कैसे करेंगे? Pathअधिक विश्वसनीय तरीके प्रदान करता है।

— Gusdor

@Gusdor Pathदिए गए उदाहरण में मार्ग के एक निश्चित बाएं भाग को हटाने के लिए अधिक उपयुक्त तरीके का उपयोग करने के लिए स्वतंत्र महसूस करें , उदाहरण के लिए `C:`।

— लुसिरो

@ ल्यूकोरो ने मेरी टिप्पणी को बहुत कमज़ोर बनाया। ' प्रतिस्थापन का उपयोग करें' मुझे बहुत कुछ बताता है और मुझे एक अच्छा समाधान प्राप्त करने के लिए लिनकैप में फंसना पड़ा। उदाहरण के लिए, पैरामीटर क्या होगा? क्या आप path.SubString(2)ड्राइव अक्षर और बृहदान्त्र को भोलेपन से करने जा रहे हैं ? यदि निर्देशिका नेटवर्क साझा है तो क्या होगा? मैं Pathएक विश्वसनीय विधि के रूप में सुझाव देता हूं क्योंकि यह इस क्षेत्र में अच्छाइयों का भार प्रदान कर सकता है। इस मामले में, आप लिख सकते हैं filePath.Substring(Path.GetPathRoot(filePath).Length)। हां यह सबस्ट्रिंग का उपयोग करता है क्योंकि यह सबसे संक्षिप्त है।

— Gusdor

Answer 4

public static void DirectorySearch(string dir)
{
    try
    {
        foreach (string f in Directory.GetFiles(dir))
        {
            Console.WriteLine(Path.GetFileName(f));
        }
        foreach (string d in Directory.GetDirectories(dir))
        {
            Console.WriteLine(Path.GetFileName(d));
            DirectorySearch(d);
        }
    }
    catch (System.Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

Comments

यह आपके उत्तर को बेहतर बनाता है यदि आप कोड क्या करता है की थोड़ी व्याख्या जोड़ सकते हैं।

— एलेक्स

यह निर्देशिका के माध्यम से पुनरावृत्ति करता है और फ़ाइल नाम या निर्देशिका नामों को प्रिंट करता है। प्रत्येक आंतरिक निर्देशिका के लिए यह समान फ़ंक्शन को कॉल करता है। अधिक जानकारी के लिए: stackoverflow.com/questions/929276/…

— I.Step

Answer 5

मुझे डर है, GetFilesविधि फाइलों की सूची लौटाती है लेकिन निर्देशिकाओं की नहीं। प्रश्न में सूची मुझे संकेत देती है कि परिणाम में फ़ोल्डर्स को भी शामिल करना चाहिए। यदि आप अधिक अनुकूलित सूची चाहते हैं, तो आप कॉलिंग GetFilesऔर GetDirectoriesपुनरावर्ती प्रयास कर सकते हैं । इसे इस्तेमाल करे:

List<string> AllFiles = new List<string>();
void ParsePath(string path)
{
    string[] SubDirs = Directory.GetDirectories(path);
    AllFiles.AddRange(SubDirs);
    AllFiles.AddRange(Directory.GetFiles(path));
    foreach (string subdir in SubDirs)
        ParsePath(subdir);
}

युक्ति: यदि आपको किसी विशिष्ट विशेषता की जांच करने की आवश्यकता है, तो आप इसका उपयोग कर सकते हैं FileInfoऔर DirectoryInfoकक्षाएं लगा सकते हैं ।

Answer 6

आप FindFirstFile का उपयोग कर सकते हैं जो एक हैंडल लौटाता है और फिर एक फ़ंक्शन को कॉल करता है जो FindNextFile को कॉल करता है। यह एक अच्छा aproach है क्योंकि संदर्भित संरचना को वैकल्पिक नाम, lastTmeCaded, संशोधित, विशेषताओं आदि जैसे विभिन्न डेटा से भरा जाएगा।

लेकिन जैसा कि आप .net ढांचे का उपयोग करते हैं, आपको अप्रबंधित क्षेत्र में प्रवेश करना होगा।

Answer 7

फ़ोल्डर को बाहर करने के लिए निर्देशिका और विकल्प में नीचे जाने के लिए अधिकतम lvl के साथ कुछ उन्नत संस्करण:

using System;
using System.IO;

class MainClass {
  public static void Main (string[] args) {

    var dir = @"C:\directory\to\print";
    PrintDirectoryTree(dir, 2, new string[] {"folder3"});
  }


  public static void PrintDirectoryTree(string directory, int lvl, string[] excludedFolders = null, string lvlSeperator = "")
  {
    excludedFolders = excludedFolders ?? new string[0];

    foreach (string f in Directory.GetFiles(directory))
    {
        Console.WriteLine(lvlSeperator+Path.GetFileName(f));
    } 

    foreach (string d in Directory.GetDirectories(directory))
    {
        Console.WriteLine(lvlSeperator + "-" + Path.GetFileName(d));

        if(lvl > 0 && Array.IndexOf(excludedFolders, Path.GetFileName(d)) < 0)
        {
          PrintDirectoryTree(d, lvl-1, excludedFolders, lvlSeperator+"  ");
        }
    }
  }
}

इनपुट निर्देशिका:

-folder1
  file1.txt
  -folder2
    file2.txt
    -folder5
      file6.txt
  -folder3
    file3.txt
  -folder4
    file4.txt
    file5.txt

फ़ंक्शन का आउटपुट (फ़ोल्डर 5 की सामग्री को lvl सीमा के कारण बाहर रखा गया है और फ़ोल्डर 3 की सामग्री को बाहर रखा गया है क्योंकि यह बहिष्कृत फ़ॉर्म्स में है):

-folder1
  file1.txt
  -folder2
    file2.txt
    -folder5
  -folder3
  -folder4
    file4.txt
    file5.txt

Answer 8

यदि आपके पास डायरेक्टरी ट्री के अंदर सबफ़ोल्डर तक पहुंच नहीं है, तो Directory.GetFiles स्टॉप को प्राप्त करता है और परिणामस्वरूप प्राप्त स्ट्रिंग में एक शून्य मान उत्पन्न करता है []।

यहाँ, इस उत्तर को देखें https://stackoverflow.com/a/38959208/6310707

यह लूप के अंदर अपवाद का प्रबंधन करता है और जब तक पूरा फ़ोल्डर ट्रेस न हो जाए, तब तक काम करता रहता है।

Answer 9

तार्किक और आदेश दिया तरीका:

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

namespace DirLister
{
class Program
{
    public static void Main(string[] args)
    {
        //with reflection I get the directory from where this program is running, thus listing all files from there and all subdirectories
        string[] st = FindFileDir(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
        using ( StreamWriter sw = new StreamWriter("listing.txt", false ) )
        {
            foreach(string s in st)
            {
                //I write what I found in a text file
                sw.WriteLine(s);
            }
        }
    }

    private static string[] FindFileDir(string beginpath)
    {
        List<string> findlist = new List<string>();

        /* I begin a recursion, following the order:
         * - Insert all the files in the current directory with the recursion
         * - Insert all subdirectories in the list and rebegin the recursion from there until the end
         */
        RecurseFind( beginpath, findlist );

        return findlist.ToArray();
    }

    private static void RecurseFind( string path, List<string> list )
    {
        string[] fl = Directory.GetFiles(path);
        string[] dl = Directory.GetDirectories(path);
        if ( fl.Length>0 || dl.Length>0 )
        {
            //I begin with the files, and store all of them in the list
            foreach(string s in fl)
                list.Add(s);
            //I then add the directory and recurse that directory, the process will repeat until there are no more files and directories to recurse
            foreach(string s in dl)
            {
                list.Add(s);
                RecurseFind(s, list);
            }
        }
    }
}
}

Comments

क्या आप कृपया एक स्पष्टीकरण या इन-लाइन टिप्पणियां प्रदान कर सकते हैं, आपका कोड क्या करता है?

— मार्तीन

बेशक, यह किया है, लेकिन यह आत्म व्याख्यात्मक होना चाहिए, यह सभी निर्देशिकाओं और फ़ाइलों के माध्यम से एक सरल लूपिंग पुनरावृत्ति है

— साचा

Answer 10

निम्न उदाहरण एक निर्देशिका ट्री हैंडलिंग अपवादों में सबसे तेज़ (समानांतर नहीं) तरीका सूची फ़ाइलों और उप-फ़ोल्डरों का उदाहरण है। यह निर्देशिका का उपयोग करने के लिए तेजी से होगा। सभी निर्देशिकाओं की गणना करने के लिए SearchOption.AllDirectories का उपयोग करते हुए।

जेनेरिक स्टैक संग्रह प्रकार का उपयोग करता है, जो पहले (LIFO) स्टैक में अंतिम है और पुनरावृत्ति का उपयोग नहीं करता है। से https://msdn.microsoft.com/en-us/library/bb513869.aspx , आप सभी उप-निर्देशिका और फ़ाइलों की गणना और उन अपवादों के साथ प्रभावी ढंग से निपटने के लिए अनुमति देता है।

    public class StackBasedIteration
{
    static void Main(string[] args)
    {
        // Specify the starting folder on the command line, or in 
        // Visual Studio in the Project > Properties > Debug pane.
        TraverseTree(args[0]);

        Console.WriteLine("Press any key");
        Console.ReadKey();
    }

    public static void TraverseTree(string root)
    {
        // Data structure to hold names of subfolders to be
        // examined for files.
        Stack<string> dirs = new Stack<string>(20);

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

        while (dirs.Count > 0)
        {
            string currentDir = dirs.Pop();
            string[] subDirs;
            try
            {
                subDirs = System.IO.Directory.EnumerateDirectories(currentDir); //TopDirectoryOnly
            }
            // An UnauthorizedAccessException exception will be thrown if we do not have
            // discovery permission on a folder or file. It may or may not be acceptable 
            // to ignore the exception and continue enumerating the remaining files and 
            // folders. It is also possible (but unlikely) that a DirectoryNotFound exception 
            // will be raised. This will happen if currentDir has been deleted by
            // another application or thread after our call to Directory.Exists. The 
            // choice of which exceptions to catch depends entirely on the specific task 
            // you are intending to perform and also on how much you know with certainty 
            // about the systems on which this code will run.
            catch (UnauthorizedAccessException e)
            {                    
                Console.WriteLine(e.Message);
                continue;
            }
            catch (System.IO.DirectoryNotFoundException e)
            {
                Console.WriteLine(e.Message);
                continue;
            }

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

            catch (UnauthorizedAccessException e)
            {

                Console.WriteLine(e.Message);
                continue;
            }

            catch (System.IO.DirectoryNotFoundException e)
            {
                Console.WriteLine(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.
                    Console.WriteLine(e.Message);
                    continue;
                }
                catch (UnauthorizedAccessException e)
                {                    
                    Console.WriteLine(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);
        }
    }
}

Comments

बड़ी संख्या में फ़ाइलों और निर्देशिकाओं के लिए कार्य का उपयोग करना ?

— प्रैगनटनकोजेनो कैब्रॉन

msdn.microsoft.com/en-us/library/ff477033(v=vs.110).aspx स्टैक कलेक्शन और क्विकर का उपयोग करके उपरोक्त समाधान का समानांतर थ्रेडिंग संस्करण है।

— मार्कस

Answer 11

मैं निम्नलिखित कोड का उपयोग एक ऐसे फॉर्म के साथ करता हूं जिसमें 2 बटन हैं, एक बाहर निकलने के लिए और दूसरा शुरू करने के लिए। एक फ़ोल्डर ब्राउज़र डायलॉग और एक सेव फाइल डायलॉग। कोड नीचे सूचीबद्ध है और मेरे सिस्टम पर काम करता है Windows10 (64):

using System;
using System.IO;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Directory_List
{

    public partial class Form1 : Form
    {
        public string MyPath = "";
        public string MyFileName = "";
        public string str = "";

        public Form1()
        {
            InitializeComponent();
        }    
        private void cmdQuit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }    
        private void cmdGetDirectory_Click(object sender, EventArgs e)
        {
            folderBrowserDialog1.ShowDialog();
            MyPath = folderBrowserDialog1.SelectedPath;    
            saveFileDialog1.ShowDialog();
            MyFileName = saveFileDialog1.FileName;    
            str = "Folder = " + MyPath + "\r\n\r\n\r\n";    
            DirectorySearch(MyPath);    
            var result = MessageBox.Show("Directory saved to Disk!", "", MessageBoxButtons.OK);
                Application.Exit();    
        }    
        public void DirectorySearch(string dir)
        {
                try
            {
                foreach (string f in Directory.GetFiles(dir))
                {
                    str = str + dir + "\\" + (Path.GetFileName(f)) + "\r\n";
                }    
                foreach (string d in Directory.GetDirectories(dir, "*"))
                {

                    DirectorySearch(d);
                }
                        System.IO.File.WriteAllText(MyFileName, str);

            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Answer 12

using System.IO;
using System.Text;
string[] filePaths = Directory.GetFiles(@"path", "*.*", SearchOption.AllDirectories);

Comments

आपका उत्तर पहले से मौजूद शीर्ष मत वाले उत्तर में कुछ भी नया नहीं जोड़ता है।

— डिफ़ॉल्ट लोकेल

यह भी गलत है, क्योंकि यह किसी भी निर्देशिका (निर्दिष्ट प्रश्न के रूप में) को वापस नहीं करता है, केवल वास्तविक फाइलें।

— एलेस्टेयर माव

Answer 13

थोड़ा सा सरल और धीरे लेकिन काम करने वाला !! यदि आप एक फ़ाइलपथ को मूल रूप से नहीं देते हैं तो "FixPath" का उपयोग करें यह केवल उदाहरण है .... आप सही फ़ाइल खोज सकते हैं जो आप चाहते हैं, मैंने एक गलती की, जब मैंने सूची का नाम चुना क्योंकि "TemFileList खोजा सूची" है तो उस पर ले .... और "त्रुटिवादी" खुद के लिए बोलता है

 static public void Search(string path, string fileType, List<string> temporaryFileList, List<string> errorList)
    {

        List<string> temporaryDirectories = new List<string>();

        //string fix = @"C:\Users\" + Environment.UserName + @"\";
        string fix = @"C:\";
        string folders = "";
        //Alap útvonal megadása 
        if (path.Length != 0)
        { folders = path; }
        else { path = fix; }

        int j = 0;
        int equals = 0;
        bool end = true;

        do
        {

            equals = j;
            int k = 0;

            try
            {

                int foldersNumber = 
                Directory.GetDirectories(folders).Count();
                int fileNumber = Directory.GetFiles(folders).Count();

                if ((foldersNumber != 0 || fileNumber != 0) && equals == j)
                {

                    for (int i = k; k < 
                    Directory.GetDirectories(folders).Length;)
                    {

             temporaryDirectories.Add(Directory.GetDirectories(folders)[k]);
                        k++;
                    }

                    if (temporaryDirectories.Count == j)
                    {
                        end = false;
                        break;
                    }
                    foreach (string files in Directory.GetFiles(folders))
                    {
                        if (files != string.Empty)
                        {
                            if (fileType.Length == 0)
                            {
                                temporaryDirectories.Add(files);
                            }
                            else
                            {

                                if (files.Contains(fileType))
                                {
                                    temporaryDirectories.Add(files);

                                }
                            }
                        }
                        else
                        {
                            break;
                        }
                    }

                }

                equals++;

                for (int i = j; i < temporaryDirectories.Count;)
                {
                    folders = temporaryDirectories[i];
                    j++;
                    break;
                }

            }
            catch (Exception ex)
            {
                errorList.Add(folders);

                for (int i = j; i < temporaryDirectories.Count;)
                {
                    folders = temporaryDirectories[i];
                    j++;
                    break;
                }
            }
        } while (end);
    }

Answer 14

स्ट्रिंग की सूची बनाएँ

    public static List<string> HTMLFiles = new List<string>();

 private void Form1_Load(object sender, EventArgs e)
        {

     HTMLFiles.AddRange(Directory.GetFiles(@"C:\DataBase", "*.txt"));
            foreach (var item in HTMLFiles)
            {
                MessageBox.Show(item);
            }

}

Comments

यह उप निर्देशिका नहीं मिलता है।

— तिवदेव

Answer 15

dir / s / b । > results.txt

/ s = सबफ़ोल्डर्स / बी = परिणाम