Partager via

Comment : énumérer des répertoires et des fichiers

  • Article

À partir du .NET Framework version 4, vous pouvez énumérer des répertoires et des fichiers à l'aide de méthodes qui retournent une collection énumérable de chaînes de leurs noms. Vous pouvez également utiliser des méthodes qui retournent une collection énumérable d'objets DirectoryInfo, FileInfo ou FileSystemInfo. Dans les versions antérieures du .NET Framework, vous pouviez uniquement obtenir des tableaux de ces collections. Les collections énumérables fournissent de meilleures performances que les tableaux.

Vous pouvez également utiliser les collections énumérables obtenues à partir de ces méthodes pour fournir le paramètre IEnumerable<T> pour les constructeurs de classes de collection telles que la classe List<T>.

Si vous voulez obtenir uniquement les noms de répertoires ou fichiers, utilisez les méthodes d'énumération de la classe Directory. Si vous voulez obtenir d'autres propriétés des répertoires ou fichiers, utilisez les classes FileSystemInfo et DirectoryInfo. Vous pouvez également énumérer les lignes d'un fichier texte.

Le tableau suivant fournit un guide pour les méthodes qui retournent des collections énumérables.

Pour énumérer

Collection énumérable à retourner

Méthode à utiliser

Répertoires

Noms de répertoires.

Directory.EnumerateDirectories

Informations sur le répertoire (DirectoryInfo).

DirectoryInfo.EnumerateDirectories

Fichiers

Noms de fichiers.

Directory.EnumerateFiles

Informations sur le fichier (FileInfo).

DirectoryInfo.EnumerateFiles

Informations sur le système de fichiers

Entrées du système de fichiers.

Directory.EnumerateFileSystemEntries

Informations sur le système de fichiers (FileSystemInfo).

DirectoryInfo.EnumerateFileSystemInfos

Lignes d'un fichier texte

Lignes d'un fichier.

File.ReadLines

Bien que vous puissiez énumérer immédiatement tous les fichiers des sous-répertoires d'un répertoire parent à l'aide de l'option AllDirectories, les exceptions d'accès non autorisé (UnauthorizedAccessException) peuvent entraîner une énumération incomplète. Si ces exceptions sont possibles, vous pouvez les intercepter et continuer en commençant par énumérer les répertoires, puis les fichiers.

Si vous exécutez Windows XP ou une version antérieure, une opération de suppression sur un fichier ou un dossier qui suit une énumération peut échouer si un handle ouvert demeure sur l'un des dossiers ou des fichiers énumérés. Dans ce cas, vous devez induire un garbage collection pour supprimer les handles ouverts.

Pour énumérer des noms de répertoires

  • Utilisez la méthode Directory.EnumerateDirectories(String) pour obtenir la liste des noms de répertoires de niveau supérieur dans un chemin d'accès spécifié.

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

Pour énumérer des noms de fichiers dans tous les répertoires

  • Utilisez la méthode Directory.EnumerateFiles(String, String, SearchOption) pour rechercher dans tous les répertoires et obtenir la liste des noms de fichiers figurant dans un chemin d'accès spécifié qui correspondent à un modèle de recherche spécifié.

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

Pour énumérer une collection d'objets DirectoryInfo

  • Utilisez la méthode DirectoryInfo.EnumerateDirectories pour obtenir une collection de répertoires de niveau supérieur.

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

Pour énumérer une collection d'objets FileInfo dans tous les répertoires

  • Utilisez la méthode DirectoryInfo.EnumerateFiles pour obtenir une collection des fichiers qui correspondent à un modèle de recherche spécifié dans tous les répertoires. Cet exemple énumère d'abord les répertoires de niveau supérieur pour intercepter les exceptions d'accès non autorisé possibles, puis énumère les fichiers.

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

    }
}

Pour supprimer des handles ouverts dans les répertoires ou les fichiers énumérés

  1. Créez une méthode personnalisée (ou une fonction en Visual Basic) pour qu'elle contienne votre code d'énumération.

  2. Appliquez l'attribut MethodImplAttribute avec l'option NoInlining à la nouvelle méthode. Par exemple :

    [MethodImplAttribute(MethodImplOptions.NoInlining)]
Private void Enumerate()

  3. Incluez les appels de méthode suivants, qui seront exécutés après votre code d'énumération :

Voir aussi

Concepts

E/S de fichier de base