it-swarm.com.de

Listet alle Dateien und Verzeichnisse in einem Verzeichnis + Unterverzeichnissen auf

Ich möchte alle Dateien und Verzeichnisse auflisten, die in einem Verzeichnis und Unterverzeichnissen dieses Verzeichnisses enthalten sind. Wenn ich C:\als Verzeichnis wähle, würde das Programm jede Datei und jeden Ordner auf der Festplatte erhalten, auf die es Zugriff hatte.

Eine Liste könnte aussehen

 fd\1.txt 
 fd\2.txt 
 fd\a\
 fd\b\
 fd\a\1.txt 
 fd\a\2.txt 
 fd\a\a\
 fd\a\b\
 fd\b\1.txt 
 fd\b\2.txt 
 fd\b\a 
 fd\b\b 
 fd\a\a\1.txt 
 fd\a\a\a\
 fd\a\b\1.txt 
 fd\a\b\a
 fd\b\a\1.txt 
 fd\b\a\a\
 fd\b\b\1.txt 
 fd\b\b\a 
77
derp_in_mouth
string[] allfiles = Directory.GetFiles("path/to/dir", "*.*", SearchOption.AllDirectories);

dabei ist *.* ein Muster, um Dateien zu finden

Wenn das Verzeichnis auch benötigt wird, können Sie folgendermaßen vorgehen:

 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();
 }
153
Ruslan F.

Directory.GetFileSystemEntries existiert in .NET 4.0+ und gibt sowohl Dateien als auch Verzeichnisse zurück. Nenne es so:

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

Beachten Sie, dass Versuche mit der Auflistung des Inhalts von Unterverzeichnissen, auf die Sie keinen Zugriff haben (UnauthorizedAccessException), nicht möglich sind. Dies kann jedoch für Ihre Anforderungen ausreichend sein.

39
Alastair Maw

Verwenden Sie die Methoden GetDirectories und GetFiles , um die Ordner und Dateien abzurufen.

Verwenden Sie SearchOptionAllDirectories, um die Ordner und Dateien in den Unterordnern zu erhalten.

13
Guffa
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);
    }
}
8
Evan Dangol

Ich fürchte, die GetFiles-Methode gibt eine Liste von Dateien zurück, nicht jedoch die Verzeichnisse. Die Liste in der Frage fordert mich auf, das Ergebnis sollte auch die Ordner enthalten. Wenn Sie eine individuellere Liste wünschen, können Sie versuchen, GetFiles und GetDirectories rekursiv aufzurufen. Versuche dies:

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

Tipp: Sie können FileInfo- und DirectoryInfo-Klassen verwenden, wenn Sie bestimmte Attribute überprüfen möchten.

3
Krishna Sarma

Sie können FindFirstFile verwenden, das ein Handle zurückgibt und dann rekursiv eine Funktion aufgerufen, die FindNextFile aufruft. Dies ist ein guter Ansatz, da die Struktur, auf die verwiesen wird, mit verschiedenen Daten gefüllt wird, z

Wenn Sie jedoch das .net-Framework verwenden, müssen Sie den nicht verwalteten Bereich betreten.

1

Ich verwende den folgenden Code mit einem Formular, das 2 Schaltflächen enthält, eine zum Beenden und die andere zum Starten. Ein Ordnerbrowser-Dialogfeld und ein Dialogfeld zum Speichern von Dateien. Der Code ist unten aufgeführt und funktioniert auf meinem System 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);
            }
        }
    }
}
0
Garry

Im folgenden Beispiel werden mit der Methode schnellste (nicht parallelisiert) Dateien und Unterordner in einer Verzeichnisstruktur aufgelistet, die Ausnahmen behandeln. Die Verwendung von Directory.EnumerateDirectories mit SearchOption.AllDirectories wäre schneller, um alle Verzeichnisse aufzulisten. Diese Methode schlägt jedoch fehl, wenn eine UnauthorizedAccessException oder PathTooLongException getroffen wird. 

Verwendet den generischen Stack-Auflistungstyp, der ein LIFO-Stack (Last-In-First-Out) ist und keine Rekursion verwendet. Unter https://msdn.Microsoft.com/de-de/library/bb513869.aspx können Sie alle Unterverzeichnisse und Dateien auflisten und diese Ausnahmen wirksam behandeln.

    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);
        }
    }
}
0
Markus

der logische und geordnete Weg:

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);
            }
        }
    }
}
}
0
Sascha

Wenn Sie keinen Zugriff auf einen Unterordner in der Verzeichnisstruktur haben, stoppt Directory.GetFiles und löst die Ausnahme aus, was zu einem Nullwert in der empfangenden Zeichenfolge [] führt. 

Hier finden Sie diese Antwort https://stackoverflow.com/a/38959208/6310707

Es verwaltet die Ausnahme innerhalb der Schleife und arbeitet so lange weiter, bis der gesamte Ordner durchlaufen ist.

0
Shubham Kumar