कैसे सी # में एक निर्देशिका में सभी फ़ाइलों को पुन: सूचीबद्ध करने के लिए?

Question

C # में एक डायरेक्टरी और चाइल्ड डायरेक्टरीज़ की सभी फाइलों को कैसे रिकर्सिबल करें?

Comments

आप कहाँ आबाद करना चाहते हैं? अगर पेड़ ... यहाँ उदाहरण dreamincode.net/code/snippet2591.htm है

— आर्सेन

स्ट्रिंग [] फ़ाइल नाम = Directory.GetFiles (पथ, "*", SearchOption.AllDirectories)

— ब्रूस

आप इस प्रश्न को देखना चाह सकते हैं जहाँ मैंने एक कोड नमूना प्रस्तुत किया है जो ट्री व्यू में निर्देशिका संरचना को प्रस्तुत करने के लिए पुनरावर्तन का उपयोग करता है। अधिकांश मामलों में तर्क समान होना चाहिए।

— सेरेब्रस

कोई परिणाम नहीं ...: इस के साथ समस्या यह है कि यह बहुत आसानी से टूट जाता है आप एक ही डायरेक्ट्री तक पहुंच नहीं है, तो है

— मार्क Gravell

यदि आप कुछ फ़ाइलों के एक्सेस न होने पर परेशानी में हैं, तो

— एन्युमरेटिंग

Answer 1

इस लेख में आप सभी की जरूरत है। फ़ाइलों की खोज करने और नामों की तुलना करने के विपरीत, केवल नामों का प्रिंट आउट लें।

इसे इस तरह संशोधित किया जा सकता है:

static void DirSearch(string sDir)
{
    try
    {
        foreach (string d in Directory.GetDirectories(sDir))
        {
            foreach (string f in Directory.GetFiles(d))
            {
                Console.WriteLine(f);
            }
            DirSearch(d);
        }
    }
    catch (System.Exception excpt)
    {
        Console.WriteLine(excpt.Message);
    }
}

बार्लोप द्वारा जोड़ा गया

गोनले ने उल्लेख किया है कि ऊपर दी गई फ़ाइलों को वर्तमान निर्देशिका में सूचीबद्ध नहीं किया गया है और यह सुझाव दिया जाता है कि निर्देशिका को प्राप्त करने वाले भाग के बाहर फ़ाइल लिस्टिंग भाग को रखा जाए। निम्नलिखित ऐसा करेंगे। इसमें एक रिटलाइन लाइन भी शामिल है जिसे आप अनसुना कर सकते हैं, जो यह पता लगाने में मदद करता है कि आप रिकर्सन में कहां हैं जो कॉल को दिखाने में मदद कर सकता है कि रिकर्सन कैसे काम करता है।

            DirSearch_ex3("c:\\aaa");
            static void DirSearch_ex3(string sDir)
            {
                //Console.WriteLine("DirSearch..(" + sDir + ")");
                try
                {
                    Console.WriteLine(sDir);

                    foreach (string f in Directory.GetFiles(sDir))
                    {
                        Console.WriteLine(f);
                    }

                    foreach (string d in Directory.GetDirectories(sDir))
                    {
                        DirSearch_ex3(d);
                    }
                }
                catch (System.Exception excpt)
                {
                    Console.WriteLine(excpt.Message);
                }
            }

Comments

यह विधि प्रारंभिक निर्देशिका के लिए फाइलों को सूचीबद्ध नहीं करती है, केवल यह उप डायर और निचला है। मैं GetDirectories के बाहर GetFiles को स्थानांतरित करूँगा

— GONeale

कभी-कभी कोई भी प्रारंभिक निर्देशिका के लिए फाइलें नहीं चाहता है, इस मामले में यह काफी छोटी संरचनाओं के लिए एकदम सही है। बहुत बड़ी सूची के लिए, मार्क ग्रेवेल के समाधान जैसे कुछ का उपयोग करें: stackoverflow.com/a/929418/91189

— जोसेफ गेब्रियल

@ गौना सही है। यह उपयोगकर्ता के लिए इनपुट रूट डायरेक्टरी की फाइल लिस्टिंग की अपेक्षा न करना बहुत कम प्रशंसनीय है। इनपुट शब्द यहाँ प्रमुख है। यह एक कारण के लिए इनपुट किया गया है।

— फ्लोरिन मिर्चेया

मुझे आंतरिक फ़ॉरच लूप के इर्द-गिर्द ट्राई कैच जोड़ना पड़ा, अन्यथा यह पहुंच से बाहर होने वाली त्रुटियों को जारी नहीं रखता है

— शॉन वर्माक

आपको अपवाद को पकड़ने से बचना चाहिए - क्या आप वास्तव में उदाहरण के लिए एक OutOfememoryException को पकड़ना चाहेंगे? केवल वही पकड़ें जो आप संभाल सकते हैं।

— अलास्टेयरट्री

Answer 2

ध्यान दें कि .NET 4.0 में फ़ाइल-आधारित (माना जाता है कि बजाय सरणी-आधारित) फ़ाइल में बनाए गए कार्य हैं:

foreach (string file in Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories))
{
    Console.WriteLine(file);
}

फिलहाल मैं नीचे की तरह कुछ का उपयोग करेंगे; यदि आपके पास एक उप-डायर तक पहुंच नहीं है, तो इनबिल्ट पुनरावर्ती विधि बहुत आसानी से टूट जाती है ...; Queue<string>उपयोग बहुत ज्यादा कॉल-ढेर प्रत्यावर्तन से बचा जाता है, और इटरेटर ब्लॉक हमें एक विशाल सरणी होने से बचा जाता है।

static void Main() {
    foreach (string file in GetFiles(SOME_PATH)) {
        Console.WriteLine(file);
    }
}

static IEnumerable<string> GetFiles(string path) {
    Queue<string> queue = new Queue<string>();
    queue.Enqueue(path);
    while (queue.Count > 0) {
        path = queue.Dequeue();
        try {
            foreach (string subDir in Directory.GetDirectories(path)) {
                queue.Enqueue(subDir);
            }
        }
        catch(Exception ex) {
            Console.Error.WriteLine(ex);
        }
        string[] files = null;
        try {
            files = Directory.GetFiles(path);
        }
        catch (Exception ex) {
            Console.Error.WriteLine(ex);
        }
        if (files != null) {
            for(int i = 0 ; i < files.Length ; i++) {
                yield return files[i];
            }
        }
    }
}

Comments

@soandos पुनरावर्ती बिंदु पर EnumerateFiles IOException को फेंकता है "फ़ाइल का नाम सिस्टम द्वारा हल नहीं किया जा सकता है"

— SerG

उन सभी के लिए जो जानना चाहते हैं कि क्या फाइल एक्सटेंशन के बिना*.* फाइलें भी शामिल हैं : हां, यह एक मिनट पहले परीक्षण किया गया था।

— टोबियास Knauss

इस का उपयोग करने के लिए आप जोड़ने की आवश्यकता होगीusing System.IO;

— को पुनः स्थापित मोनिका - अलविदा एसई

@Wikis और उपयोग करने के लिए Consoleआप जोड़ने की आवश्यकता होगी using System;- लेकिन जब से आईडीई सभी आवश्यक जोड़ सकते हैं usingनिर्देशों आप के लिए , और के बाद से हम कुछ भी यहाँ विदेशी उपयोग नहीं कर रहे हैं, यह आम है उन्हें शामिल नहीं करने के लिए (Ctrl +।)। ओह, आप भी एक की आवश्यकता होगी classपरिभाषा आदि बस कह '

— मार्क Gravell

@MarcGravell अब हम .net कोर और विजुअल स्टूडियो कोड दुनिया में हैं, इसलिए बयानों का उपयोग करना हमेशा किसी भी उदाहरण में शामिल है। खोजों और व्यर्थ "याक शेविंग" की एक श्रृंखला को बचाने के लिए .net कोड

— JohnC

Answer 3

Directory.GetFiles("C:\\", "*.*", SearchOption.AllDirectories)

Comments

यदि लॉगिन उपयोगकर्ता के पास कुछ फ़ोल्डरों तक पहुंच नहीं है, तो त्रुटि से कैसे बचें।

— रोमिल कुमार जैन

@Romil मुझे विश्वास नहीं है कि यह कोड स्निपेट पूर्ण कार्यक्षमता को इंगित करने की कोशिश कर रहा है, केवल कच्ची कार्यक्षमता जो ओपी चाह रहा था। साझा करने के लिए धन्यवाद, पेस्कोमा!

— kayleeFrye_onDeck

@kayleeFrye_onDeck, मैं केवल एक मामले में एक चिंता का विषय है अगर वहाँ किसी भी फ़ोल्डर के लिए उठाया है फ़ाइलें प्राप्त कर रहा है। इस चिंता के कारण हम अपने कस्टम पुनरावर्ती कार्य को लागू करते हैं।

— रोमिल कुमार जैन

आप इस समाधान के साथ "अनधिकृत असफलता" प्राप्त करेंगे। आपके पास एक समाधान होना चाहिए जो इस तरह से त्रुटियों को संभाल सकता है।

— केयर्न

Answer 4

.NET 4.5 में, कम से कम, यह संस्करण है जो बहुत छोटा है और सूची में शामिल करने के लिए किसी भी फ़ाइल मानदंड के मूल्यांकन का अतिरिक्त बोनस है:

public static IEnumerable<string> GetAllFiles(string path, 
                                              Func<FileInfo, bool> checkFile = null)
{
    string mask = Path.GetFileName(path);
    if (string.IsNullOrEmpty(mask)) mask = "*.*";
    path = Path.GetDirectoryName(path);
    string[] files = Directory.GetFiles(path, mask, SearchOption.AllDirectories);

    foreach (string file in files)
    {
        if (checkFile == null || checkFile(new FileInfo(file)))
            yield return file;
    }
}

इस तरह का उपयोग करें:

var list = GetAllFiles(mask, (info) => Path.GetExtension(info.Name) == ".html").ToList();

Comments

यह एक ऐसे मामले को संभालता नहीं है जहाँ आपके पास एक खाली निर्देशिका है ... फ़ंक्शन के अंदर कोई रिटर्न स्टेटमेंट नहीं है।

— FrumkinWY

@FramkinWY एक खाली निर्देशिका के साथ क्या होता है? मेरे पास अभी इसका परीक्षण करने के लिए मशीन नहीं है।

— जॉन केस्टर

Answer 5

IEnumerable<string> GetFilesFromDir(string dir) =>
 Directory.EnumerateFiles(dir).Concat(
 Directory.EnumerateDirectories(dir)
          .SelectMany(subdir => GetFilesFromDir(subdir)));

Answer 6

फ़्रेमवर्क 2.0 में आप उपयोग कर सकते हैं (यह रूट फ़ोल्डर की फ़ाइलों को सूचीबद्ध करता है, यह सबसे लोकप्रिय उत्तर है):

static void DirSearch(string dir)
{
    try
    {
        foreach (string f in Directory.GetFiles(dir))
            Console.WriteLine(f);
        foreach (string d in Directory.GetDirectories(dir))
        {
            Console.WriteLine(d);
            DirSearch(d);
        }

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

Answer 7

कुछ बेहतरीन जवाब लेकिन इन जवाबों से मेरी समस्या हल नहीं हुई।

जैसे ही एक फ़ोल्डर अनुमति मुद्दा उठता है: "अनुमति अस्वीकृत" कोड विफल रहता है। यह वही है जो मुझे "अनुमति अस्वीकृत" मुद्दे के आसपास मिलता था:

private int counter = 0;

    private string[] MyDirectories = Directory.GetDirectories("C:\\");

    private void ScanButton_Click(object sender, EventArgs e)
    {
        Thread MonitorSpeech = new Thread(() => ScanFiles());
        MonitorSpeech.Start();
    }

    private void ScanFiles()
    {
        string CurrentDirectory = string.Empty;

        while (counter < MyDirectories.Length)
        {
            try
            {
                GetDirectories();
                CurrentDirectory = MyDirectories[counter++];
            }
            catch
            {
                if (!this.IsDisposed)
                {
                    listBox1.Invoke((MethodInvoker)delegate { listBox1.Items.Add("Access Denied to : " + CurrentDirectory); });
                }
            }
        }
    }

    private void GetDirectories()
    {
        foreach (string directory in MyDirectories)
        {
            GetFiles(directory);
        }
    }

    private void GetFiles(string directory)
    {
        try
        {
            foreach (string file in Directory.GetFiles(directory, "*"))
            {
                listBox1.Invoke((MethodInvoker)delegate { listBox1.Items.Add(file); });
            }
        }
        catch
        {
            listBox1.Invoke((MethodInvoker)delegate { listBox1.Items.Add("Access Denied to : " + directory); });
        }
    }

आशा है कि यह दूसरों की मदद करता है।

Answer 8

एक सरल और साफ समाधान

/// <summary>
/// Scans a folder and all of its subfolders recursively, and updates the List of files
/// </summary>
/// <param name="sFullPath">Full path of the folder</param>
/// <param name="files">The list, where the output is expected</param>
internal static void EnumerateFiles(string sFullPath, List<FileInfo> fileInfoList)
{
    try
    {
        DirectoryInfo di = new DirectoryInfo(sFullPath);
        FileInfo[] files = di.GetFiles();

        foreach (FileInfo file in files)
            fileInfoList.Add(file);

        //Scan recursively
        DirectoryInfo[] dirs = di.GetDirectories();
        if (dirs == null || dirs.Length < 1)
            return;
        foreach (DirectoryInfo dir in dirs)
            EnumerateFiles(dir.FullName, fileInfoList);

    }
    catch (Exception ex)
    {
        Logger.Write("Exception in Helper.EnumerateFiles", ex);
    }
}

Comments

आप मैन्युअल रूप से क्या कर रहे हैं DirectoryInfo.GetFiles () आप के लिए बॉक्स से बाहर कर देगा - बस SearchOption.AllDirectories के साथ अधिभार का उपयोग करें और यह अपने आप सभी को फिर से लॉन्च करेगा। तो यह एक जटिल समाधान है।

— philw

Answer 9

मैं DirectoryInfo का उपयोग करना पसंद करता हूं क्योंकि मैं FileInfo प्राप्त कर सकता हूं, न कि केवल तार।

        string baseFolder = @"C:\temp";
        DirectoryInfo di = new DirectoryInfo(baseFolder);

        string searchPattern = "*.xml";

        ICollection<FileInfo> matchingFileInfos = di.GetFiles(searchPattern, SearchOption.AllDirectories)
            .Select(x => x)
            .ToList();

मैं इस मामले में भविष्य में मुझे भविष्य के फ़िल्टरिंग की आवश्यकता है .. FileInfo के गुणों पर आधारित।

        string baseFolder = @"C:\temp";
        DirectoryInfo di = new DirectoryInfo(baseFolder);

        string searchPattern = "*.xml";

        ICollection<FileInfo> matchingFileInfos = di.GetFiles(searchPattern, SearchOption.AllDirectories)
            .Where(x => x.LastWriteTimeUtc < DateTimeOffset.Now)
            .Select(x => x)
            .ToList();

अगर जरूरत पड़ी तो मैं स्ट्रिंग्स का भी सहारा ले सकता हूं। (और अभी भी फिल्टर / जहां-जहां सामान के लिए भविष्य का प्रमाण है।

        string baseFolder = @"C:\temp";
        DirectoryInfo di = new DirectoryInfo(baseFolder);

        string searchPattern = "*.xml";

        ICollection<string> matchingFileNames = di.GetFiles(searchPattern, SearchOption.AllDirectories)
            .Select(x => x.FullName)
            .ToList();

ध्यान दें कि " । " मान्य खोज पैटर्न अगर आप विस्तार से filer करना चाहते हैं।

Answer 10

private void GetFiles(DirectoryInfo dir, ref List<FileInfo> files)
{
    try
    {
        files.AddRange(dir.GetFiles());
        DirectoryInfo[] dirs = dir.GetDirectories();
        foreach (var d in dirs)
        {
            GetFiles(d, ref files);
        }
    }
    catch (Exception e)
    {

    }
}

Comments

पैरामीटर क्यों filesहै ref? कोई जरूरत नहीं है।

— मैसिमिलियानो क्रूस

@MassimilianoKraus मैं तर्क देता हूं कि आवश्यकता नहीं होने पर, यह स्पष्ट कर देता है कि उसकी विधि बदल जाएगी filesऔर आप बस new List<FileInfo>()पैरामीटर के रूप में नहीं दे सकते हैं जो बेकार होगा। कुछ उप-अनुकूलन के लिए अनुमति दे सकते हैं और जब तक आवश्यक न हो एक नई वस्तु बनाने से बचें।

— jeromej

@JeromeJ यदि आप जानते हैं कि OOP क्या है, तो आप जानते हैं कि जब भी आप किसी विधि को किसी वस्तु को पास करते हैं, तो वह विधि वस्तु के गुणों / क्षेत्रों को बदल सकती है। तो refकुछ भी स्पष्ट नहीं करता है। refके उद्देश्य पूरे बदलने के लिए है filesयह एक खतरनाक ऑपरेशन है और यहाँ उस के लिए कोई ज़रूरत नहीं है: तुम सिर्फ सूची भर सकते हैं, आप उस पर एक और सूची के लिए फिर से बात करने के लिए की जरूरत नहीं है यहां तक कि विधि की कॉलर के लिए सूचक ढेर। refकेवल बहुत विशेष मामलों में उपयोग किया जाना चाहिए; ज्यादातर समय आपको चीजों को अधिक कार्यात्मक-प्रतिमान तरीके से लागू करने की आवश्यकता होती है।

— मासिमिलियानो क्रूस

Answer 11

से बचने के लिए UnauthorizedAccessException, मैं उपयोग करता हूं:

var files = GetFiles(@"C:\", "*.*", SearchOption.AllDirectories);
foreach (var file in files)
{
    Console.WriteLine($"{file}");
}

public static IEnumerable<string> GetFiles(string path, string searchPattern, SearchOption searchOption)
{
    var foldersToProcess = new List<string>()
    {
        path
    };

    while (foldersToProcess.Count > 0)
    {
        string folder = foldersToProcess[0];
        foldersToProcess.RemoveAt(0);

        if (searchOption.HasFlag(SearchOption.AllDirectories))
        {
            //get subfolders
            try
            {
                var subfolders = Directory.GetDirectories(folder);
                foldersToProcess.AddRange(subfolders);
            }
            catch (Exception ex)
            {
                //log if you're interested
            }
        }

        //get files
        var files = new List<string>();
        try
        {
            files = Directory.GetFiles(folder, searchPattern, SearchOption.TopDirectoryOnly).ToList();
        }
        catch (Exception ex)
        {
            //log if you're interested
        }

        foreach (var file in files)
        {
            yield return file;
        }
    }
}

Answer 12

यदि आपको केवल फ़ाइल नाम की आवश्यकता है और जब से मैं वास्तव में समाधान के अधिकांश (फीचर-वार या पठनीय-वार) को पसंद नहीं करता, तो इस आलसी के बारे में कैसे?

private void Foo()
{
  var files = GetAllFiles("pathToADirectory");
  foreach (string file in files)
  {
      // Use can use Path.GetFileName() or similar to extract just the filename if needed
      // You can break early and it won't still browse your whole disk since it's a lazy one
  }
}

/// <exception cref="T:System.IO.DirectoryNotFoundException">The specified path is invalid (for example, it is on an unmapped drive).</exception>
/// <exception cref="T:System.UnauthorizedAccessException">The caller does not have the required permission.</exception>
/// <exception cref="T:System.IO.IOException"><paramref name="path" /> is a file name.-or-A network error has occurred.</exception>
/// <exception cref="T:System.IO.PathTooLongException">The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters and file names must be less than 260 characters.</exception>
/// <exception cref="T:System.ArgumentNullException"><paramref name="path" /> is null.</exception>
/// <exception cref="T:System.ArgumentException"><paramref name="path" /> is a zero-length string, contains only white space, or contains one or more invalid characters as defined by <see cref="F:System.IO.Path.InvalidPathChars" />.</exception>
[NotNull]
public static IEnumerable<string> GetAllFiles([NotNull] string directory)
{
  foreach (string file in Directory.GetFiles(directory))
  {
    yield return file; // includes the path
  }

  foreach (string subDir in Directory.GetDirectories(directory))
  {
    foreach (string subFile in GetAllFiles(subDir))
    {
      yield return subFile;
    }
  }
}

Answer 13

सबसे छोटा रिकॉर्ड

string files = Directory.GetFiles(@"your_path", "*.jpg", SearchOption.AllDirectories);

Answer 14

हर्नॉल्डो के आधार पर इस पर मेरा एंगल है, अगर आपको एक निश्चित पैटर्न के नाम वाली फाइलें खोजने की आवश्यकता है, जैसे कि XML फाइलें जो कहीं न कहीं उनके नाम में एक विशेष स्ट्रिंग हैं:

// call this like so: GetXMLFiles("Platypus", "C:\\");
public static List<string> GetXMLFiles(string fileType, string dir)
{
    string dirName = dir; 
    var fileNames = new List<String>();
    try
    {
        foreach (string f in Directory.GetFiles(dirName))
        {
            if ((f.Contains(fileType)) && (f.Contains(".XML")))
            {
                fileNames.Add(f);
            }
        }
        foreach (string d in Directory.GetDirectories(dirName))
        {
            GetXMLFiles(fileType, d);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
    return fileNames;
}

Answer 15

मॉडल, कस्टम कार्यान्वयन के लिए फ़ाइलों और फ़ोल्डरों की सूची बनाना।
यह आपकी आरंभ निर्देशिका से शुरू होने वाली सभी फ़ाइलों और फ़ोल्डरों की पूरी सूची बनाता है।

public class DirOrFileModel
    {
        #region Private Members

        private string _name;
        private string _location;
        private EntryType _entryType;

        #endregion

        #region Bindings

        public string Name
        {
            get { return _name; }
            set
            {
                if (value == _name) return;
                _name = value;
            }
        }

        public string Location
        {
            get { return _location; }
            set
            {
                if (value == _location) return;
                _location = value;
            }
        }

        public EntryType EntryType
        {
            get { return _entryType; }
            set
            {
                if (value == _entryType) return;
                _entryType = value;
            }
        }

        public ObservableCollection<DirOrFileModel> Entries { get; set; }

        #endregion

        #region Constructor

        public DirOrFileModel()
        {
            Entries = new ObservableCollection<DirOrFileModel>();
        }

        #endregion
    }

    public enum EntryType
    {
        Directory = 0,
        File = 1
    }

तरीका:

 static DirOrFileModel DirSearch(DirOrFileModel startDir)
        {
            var currentDir = startDir;
            try
            {
                foreach (string d in Directory.GetDirectories(currentDir.Location))
                {
                    var newDir = new DirOrFileModel
                    {
                        EntryType = EntryType.Directory,
                        Location = d,
                        Name = Path.GetFileName(d)
                    };
                    currentDir.Entries.Add(newDir);

                    DirSearch(newDir);
                }

                foreach (string f in Directory.GetFiles(currentDir.Location))
                {
                    var newFile = new DirOrFileModel
                    {
                        EntryType = EntryType.File,
                        Location = f,
                        Name = Path.GetFileNameWithoutExtension(f)
                    };
                    currentDir.Entries.Add(newFile);
                }

            }
            catch (Exception excpt)
            {
                Console.WriteLine(excpt.Message);
            }
            return startDir;
        }

उपयोग:

var dir = new DirOrFileModel
            {
                Name = "C",
                Location = @"C:\",
                EntryType = EntryType.Directory
            };

            dir = DirSearch(dir);

Answer 16

लघु और सरल उपाय

string dir = @"D:\PATH";

DateTime from_date = DateTime.Now.Date;
DateTime to_date = DateTime.Now.Date.AddHours(23);
var files = Directory.EnumerateFiles(dir, "*.*",SearchOption.AllDirectories).Select(i=>new FileInfo(i))
.Where(file=>file.LastWriteTime >= from_date && file.LastWriteTime <= to_date);
foreach(var fl in files)
    Console.WriteLine(fl.FullName);

Answer 17

यह एक निर्देशिका और उप निर्देशिकाओं में सभी फ़ाइलों को प्राप्त करने में मेरी मदद करता है, किसी के लिए सहायक हो सकता है। [उपरोक्त उत्तरों से प्रेरित]

static void Main(string[] args)
    {
        try
        {
            var root = @"G:\logs";
            DirectorySearch(root);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }





public static void DirectorySearch(string root, bool isRootItrated = false)
{
    if (!isRootItrated)
    {
        var rootDirectoryFiles = Directory.GetFiles(root);
        foreach (var file in rootDirectoryFiles)
        {
            Console.WriteLine(file);
        } 
    }

    var subDirectories = Directory.GetDirectories(root);
    if (subDirectories?.Any() == true)
    {
        foreach (var directory in subDirectories)
        {
            var files = Directory.GetFiles(directory);
            foreach (var file in files)
            {
                Console.WriteLine(file);
            }
            DirectorySearch(directory, true);
        }
    }
}

Answer 18

var d = new DirectoryInfo(@"C:\logs");
var list = d.GetFiles("*.txt").Select(m => m.Name).ToList();

Answer 19

फ़ोल्डर को बाहर करने के लिए निर्देशिका और विकल्प में नीचे जाने के लिए अधिकतम 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 20

यहाँ एक्स क्लेन शैनन कोड का एक संस्करण है जो एक्सेल-फाइल्स के लिए स्थिर नहीं है:

class ExcelSearcher
{
    private List<string> _fileNames;

    public ExcelSearcher(List<string> filenames)
    {
        _fileNames = filenames;
    }
    public List<string> GetExcelFiles(string dir, List<string> filenames = null)
    {

        string dirName = dir;
        var dirNames = new List<string>();
        if (filenames != null)
        {
            _fileNames.Concat(filenames);
        }
        try
        {
            foreach (string f in Directory.GetFiles(dirName))
            {
                if (f.ToLower().EndsWith(".xls") || f.ToLower().EndsWith(".xlsx"))
                {
                    _fileNames.Add(f);
                }
            }
            dirNames = Directory.GetDirectories(dirName).ToList();
            foreach (string d in dirNames)
            {
                GetExcelFiles(d, _fileNames);
            }
        }
        catch (Exception ex)
        {
            //Bam
        }
        return _fileNames;
    }

Answer 21

एक बहुत ही सरल समाधान, फ़ाइलों की एक सूची देता है।

    public static List<string> AllFilesInFolder(string folder)
    {
        var result = new List<string>();

        foreach (string f in Directory.GetFiles(folder))
        {
            result.Add(f);
        }

        foreach (string d in Directory.GetDirectories(folder))
        {
            result.AddRange(AllFilesInFolder(d));
        }

        return result;
    }

Answer 22

static void Main(string[] args)
        {
            string[] array1 = Directory.GetFiles(@"D:\");
            string[] array2 = System.IO.Directory.GetDirectories(@"D:\");
            Console.WriteLine("--- Files: ---");
            foreach (string name in array1)
            {
                Console.WriteLine(name);
            }
            foreach (string name in array2)
            {
                Console.WriteLine(name);
            }
                  Console.ReadLine();
        }

Comments

uhhh ... यह पुनरावर्ती नहीं है

— mxmissile