Postupy: Výčet souborů a adresářů

Článek
08/11/2011

Počínaje rozhraním .NET Framework verze 4, můžete vytvořit výčet adresářů a souborů pomocí metody, která vrací vyčíslitelné kolekce řetězců jejich názvů. Můžete také použít metody, které vrátí vyčíslitelné kolekce objektů DirectoryInfo, FileInfo nebo FileSystemInfo. V předchozích verzích rozhraní .NET Framework můžete pouze získat pole těchto kolekcí. Vyčíslitelné kolekce poskytují vyšší výkon než pole.

Vyčíslitelné kolekce získané z těchto metod můžete také použít pro dodání parametru IEnumerable<T> pro konstruktory kolekce tříd, například třídu List<T>.

Pokud chcete získat pouze názvy adresářů nebo souborů, použijte výčtové metody třídy Directory. Pokud chcete získat další vlastnosti adresářů nebo souborů, použijte třídy DirectoryInfo a FileSystemInfo. Můžete také provést výčet řádků textového souboru.

Následující tabulka poskytuje návod k metodám, které vracejí vyčíslitelné kolekce.

Sestavení výčtu	Navrácení vyčíslitelné kolekce	Metoda pro použití
Adresáře	Názvy adresářů.	Directory.EnumerateDirectories
	Informace adresáře (DirectoryInfo).	DirectoryInfo.EnumerateDirectories
Soubory	Názvy souborů.	Directory.EnumerateFiles
	Informace o souborech (FileInfo).	DirectoryInfo.EnumerateFiles
Informace o souborovém systému	Položky souborového systému.	Directory.EnumerateFileSystemEntries
	Informace o souborovém systému (FileSystemInfo).	DirectoryInfo.EnumerateFileSystemInfos
Řádky z textového souboru	Řádky ze souboru.	File.ReadLines

Přestože lze okamžitě provést výčet všech souborů v podadresářích nadřazeného adresáře pomocí možnosti AllDirectories, výjimky neoprávněného přístupu (UnauthorizedAccessException) mohou způsobit, že bude výčet neúplný. Pokud jsou tyto výjimky možné, můžete je zachytit a pokračovat nejprve vytvářením výčtu adresáře a poté výčtem souborů.

Pokud používáte systém Windows XP nebo starší, operace odstranění souboru nebo adresáře následující výčet selhat v případě, že je otevřený popisovač, který zůstává na jednom z výčtu adresářů nebo souborů. Pokud se vyskytuje opakovaně, musí indukovat uvolněné odebrat otevřených popisovačů.

Vytvoření výčtu názvů adresářů

Použijte metodu Directory.EnumerateDirectories(String) pro získání seznamu názvů adresářů nejvyšší úrovně v určité cestě.

Imports System.Collections.Generic
Imports System.IO
Imports System.Linq

Module Module1

    Sub Main()
        Try
            Dim dirPath As String = "\\archives\2009\reports"

            ' LINQ query.
            Dim dirs = From folder In _
                Directory.EnumerateDirectories(dirPath)
            For Each folder In dirs
                ' Remove path information from string.
                Console.WriteLine("{0}", _
                        folder.Substring(folder.LastIndexOf("\") + 1))
            Next
            Console.WriteLine("{0} directories found.", _
                dirs.Count.ToString())

            ' Optionally create a List collection.
            Dim workDirs As List(Of String) = New List(Of String)(dirs)

        Catch UAEx As UnauthorizedAccessException
            Console.WriteLine(UAEx.Message)
        Catch PathEx As PathTooLongException
            Console.WriteLine(PathEx.Message)
        End Try
    End Sub
End Module

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

class Program
{

    private static void Main(string[] args)
    {
        try
        {
            string dirPath = @"\\archives\2009\reports";

            // LINQ query.
            var dirs = from dir in 
                     Directory.EnumerateDirectories(dirPath)
                       select dir;

            // Show results.
            foreach (var dir in dirs)
            {
                // Remove path information from string.
                Console.WriteLine("{0}", 
                    dir.Substring(dir.LastIndexOf("\\") + 1));

            }
            Console.WriteLine("{0} directories found.", 
                dirs.Count<string>().ToString());

            // Optionally create a List collection.
            List<string> workDirs = new List<string>(dirs);
        }
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}

Sestavení výčtu názvů souborů ve všech adresářích

Použijte metodu Directory.EnumerateFiles(String, String, SearchOption) pro prohledání všech adresářů pro získání seznamu názvů souborů v určené cestě, která odpovídá zadanému vyhledávacímu vzorku.

Imports System.IO
Imports System.Xml.Linq
Module Module1

    Sub Main()

        Try
            Dim files = From chkFile In Directory.EnumerateFiles("c:\", "*.txt", _
                                                 SearchOption.AllDirectories)
                        From line In File.ReadLines(chkFile)
                        Where line.Contains("Microsoft")
                        Select New With {.curFile = chkFile, .curLine = line}

            For Each f In files
                Console.WriteLine("{0}\t{1}", f.curFile, f.curLine)
            Next
            Console.WriteLine("{0} files found.", _
                    files.Count.ToString())
        Catch UAEx As UnauthorizedAccessException
            Console.WriteLine(UAEx.Message)
        Catch PathEx As PathTooLongException
            Console.WriteLine(PathEx.Message)
        End Try
    End Sub
End Module

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {

        try
        {
            var files = from file in Directory.EnumerateFiles(@"c:\",
                            "*.txt", SearchOption.AllDirectories)
                        from line in File.ReadLines(file)
                        where line.Contains("Microsoft")
                        select new
                        {
                            File = file,
                            Line = line
                        };

            foreach (var f in files)
            {
                Console.WriteLine("{0}\t{1}", f.File, f.Line);
            }
            Console.WriteLine("{0} files found.", 
                files.Count().ToString());
        }
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}

Vytvoření výčtu kolekce objektů DirectoryInfo

Použijte metodu DirectoryInfo.EnumerateDirectories pro získání kolekce adresářů nejvyšší úrovně.

' Create a DirectoryInfo of the Program Files directory.
Dim dirPrograms As New DirectoryInfo("c:\program files")

Dim StartOf2009 As New DateTime(2009, 1, 1)

' LINQ query for all directories created before 2009.
Dim dirs = From dir In dirPrograms.EnumerateDirectories()
            Where dir.CreationTimeUtc < StartOf2009

' Show results.
For Each di As DirectoryInfo In dirs
    Console.WriteLine("{0}", di.Name)
Next

// Create a DirectoryInfo of the Program Files directory.
DirectoryInfo dirPrograms = new DirectoryInfo(@"c:\program files");

DateTime StartOf2009 = new DateTime(2009, 01, 01);

// LINQ query for all directories created before 2009.
var dirs = from dir in dirPrograms.EnumerateDirectories()
            where dir.CreationTimeUtc < StartOf2009
            select new
            {
                ProgDir = dir,
            };
// Show results.
foreach (var di in dirs)
{
    Console.WriteLine("{0}", di.ProgDir.Name);
}

Vytvoření výčtu kolekce objektů FileInfo ve všech adresářích

Použijte metodu DirectoryInfo.EnumerateFiles pro získání kolekce souborů, které odpovídají zadanému vyhledávacímu vzorku ve všech adresářích. Tento příklad nejprve vytvoří výčet adresářů nejvyšší úrovně, aby zachytil možné výjimky neoprávněného přístupu a pak vytvoří výčet souborů.

Imports System
Imports System.IO

Class Program
    Public Shared Sub Main(ByVal args As String())
        ' Create a DirectoryInfo object of the starting directory.
        Dim diTop As New DirectoryInfo("d:\")
        Try
            ' Enumerate the files just in the top directory.
            For Each fi In diTop.EnumerateFiles()
                Try
                    ' Display each file over 10 MB;
                    If fi.Length > 10000000 Then
                        Console.WriteLine("{0}" & vbTab & vbTab & "{1}", 
                        fi.FullName, fi.Length.ToString("N0"))
                    End If
                ' Catch unauthorized access to a file.
                Catch UnAuthTop As UnauthorizedAccessException
                    Console.WriteLine("{0}", UnAuthTop.Message)
                End Try
            Next
            ' Enumerate all subdirectories.
            For Each di In diTop.EnumerateDirectories("*")
                Try
                    ' Enumerate each file in each subdirectory.
                    For Each fi In di.EnumerateFiles("*", 
                                SearchOption.AllDirectories)
                        Try
                            ' // Display each file over 10 MB;
                            If fi.Length > 10000000 Then
                                Console.WriteLine("{0}" & vbTab &
                                vbTab & "{1}", 
                                fi.FullName, fi.Length.ToString("N0"))
                            End If
                        ' Catch unauthorized access to a file.
                        Catch UnAuthFile As UnauthorizedAccessException
                            Console.WriteLine("UnAuthFile: {0}",
                                                UnAuthFile.Message)
                        End Try
                    Next
                ' Catch unauthorized access to a subdirectory.
                Catch UnAuthSubDir As UnauthorizedAccessException
                    Console.WriteLine("UnAuthSubDir: {0}", 
                                            UnAuthSubDir.Message)
                End Try
            Next
        ' Catch error in directory path.
        Catch DirNotFound As DirectoryNotFoundException
            Console.WriteLine("{0}", DirNotFound.Message)
        ' Catch unauthorized access to a first tier directory. 
        Catch UnAuthDir As UnauthorizedAccessException
            Console.WriteLine("UnAuthDir: {0}", UnAuthDir.Message)
        ' Catch paths that are too long.
        Catch LongPath As PathTooLongException
            Console.WriteLine("{0}", LongPath.Message)
        End Try
    End Sub
End Class

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Create a DirectoryInfo object of the starting directory.
        DirectoryInfo diTop = new DirectoryInfo(@"d:\");
        try
        {
            // Enumerate the files just in the top directory.
            foreach (var fi in diTop.EnumerateFiles())
            {
                try
                {
                    // Display each file over 10 MB;
                    if (fi.Length > 10000000)
                    {
                        Console.WriteLine("{0}\t\t{1}", fi.FullName, 
                                        fi.Length.ToString("N0"));
                    }
                }
                // Catch unauthorized access to a file.
                catch (UnauthorizedAccessException UnAuthTop)
                {
                    Console.WriteLine("{0}", UnAuthTop.Message);
                }
            }
            // Enumerate all subdirectories.
            foreach (var di in diTop.EnumerateDirectories("*"))
            {
                try
                {
                    // Enumerate each file in each subdirectory.
                    foreach (var fi in di.EnumerateFiles("*",
                                    SearchOption.AllDirectories))
                    {
                        try
                        {
                            // Display each file over 10 MB;
                            if (fi.Length > 10000000)
                            {
                                Console.WriteLine("{0}\t\t{1}", 
                                  fi.FullName, fi.Length.ToString("N0"));
                            }
                        }
                         // Catch unauthorized access to a file.
                        catch (UnauthorizedAccessException UnAuthFile)
                        {
                            Console.WriteLine("UnAuthFile: {0}", 
                                            UnAuthFile.Message);
                        }
                    }
                }
                // Catch unauthorized access to a subdirectory.
                catch (UnauthorizedAccessException UnAuthSubDir)
                {
                    Console.WriteLine("UnAuthSubDir: {0}", 
                                            UnAuthSubDir.Message);
                }
            }
        }
        // Catch error in directory path.
        catch (DirectoryNotFoundException DirNotFound)
        {
            Console.WriteLine("{0}", DirNotFound.Message);
        }
        // Catch unauthorized access to a first tier directory. 
        catch (UnauthorizedAccessException UnAuthDir)
        {
            Console.WriteLine("UnAuthDir: {0}", UnAuthDir.Message);
        }
        // Catch paths that are too long. 
        catch (PathTooLongException LongPath)
        {
            Console.WriteLine("{0}", LongPath.Message);
        }

    }
}

Odebrat výčet adresářů nebo souborů otevřených popisovačů

Vytvořte vlastní metodu (nebo funkce jazyka Visual Basic) obsahuje výčet kód.
Použije MethodImplAttribute atributu s NoInlining možnost nové metody. Příklad:
```
[MethodImplAttribute(MethodImplOptions.NoInlining)]
Private void Enumerate()
```
Následující volání metody po výčtu kód patří:
- GC.Collect() Metody (bez parametrů).
- GC.WaitForPendingFinalizers() Metody.

Viz také

Koncepty

Základní vstupně-výstupní operace se soubory