Directory.EnumerateDirectories Méthode

Source:

Directory.cs

Source:

Directory.cs

Source:

Directory.cs

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path);

static member EnumerateDirectories : string -> seq<string>

Public Shared Function EnumerateDirectories (path As String) As IEnumerable(Of String)

Paramètres

Retours

Collection énumérable des noms d’affichage (chemins d’accès compris) pour les répertoires du répertoire spécifié par path.

Exceptions

Exemples

L’exemple suivant énumère les répertoires de niveau supérieur dans un chemin spécifié.

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

class Program
{
    private static void Main(string[] args)
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            List<string> dirs = new List<string>(Directory.EnumerateDirectories(docPath));

            foreach (var dir in dirs)
            {
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
            }
            Console.WriteLine($"{dirs.Count} directories found.");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine(ex.Message);
        }
        catch (PathTooLongException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

open System
open System.IO

try
    // Set a variable to the My Documents path.
    let docPath = Environment.GetFolderPath Environment.SpecialFolder.MyDocuments

    let dirs = Directory.EnumerateDirectories docPath |> Seq.toList

    for dir in dirs do
        printfn $"{dir.Substring(dir.LastIndexOf Path.DirectorySeparatorChar + 1)}"
    printfn $"{dirs.Length} directories found."

with
| :? UnauthorizedAccessException as ex ->
    printfn $"{ex.Message}"
| :? PathTooLongException as ex ->
    printfn $"{ex.Message}"

Imports System.Collections.Generic
Imports System.IO

Module Module1

    Sub Main()
        Try
            Dim dirPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

            Dim dirs As List(Of String) = New List(Of String)(Directory.EnumerateDirectories(dirPath))

            For Each folder In dirs
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}")
            Next
            Console.WriteLine($"{dirs.Count} directories found.")
        Catch ex As UnauthorizedAccessException
            Console.WriteLine(ex.Message)
        Catch ex As PathTooLongException
            Console.WriteLine(ex.Message)
        End Try

    End Sub
End Module

Remarques

Vous pouvez spécifier des informations relatives ou absolues sur le chemin dans le path paramètre. Les informations relatives au chemin d’accès sont interprétées comme relatives au répertoire de travail actuel, que vous pouvez déterminer à l’aide de la GetCurrentDirectory méthode . Les noms de répertoires retournés sont précédés de la valeur que vous avez fournie dans le path paramètre. Par exemple, si vous fournissez un chemin relatif dans le paramètre, les path noms de répertoires retournés contiennent un chemin relatif.

Les EnumerateDirectories méthodes et GetDirectories diffèrent comme suit : lorsque vous utilisez EnumerateDirectories, vous pouvez commencer à énumérer la collection de noms avant que l’ensemble de la collection soit retourné ; lorsque vous utilisez GetDirectories, vous devez attendre que l’ensemble du tableau de noms soit retourné avant de pouvoir accéder au tableau. Par conséquent, lorsque vous travaillez avec de nombreux fichiers et répertoires, EnumerateDirectories peut être plus efficace.

La collection retournée n’est pas mise en cache ; chaque appel à sur GetEnumerator la collection démarre une nouvelle énumération.

Source:

Directory.cs

Source:

Directory.cs

Source:

Directory.cs

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern);

static member EnumerateDirectories : string * string -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String) As IEnumerable(Of String)

Paramètres

Retours

Collection énumérable des noms complets (chemins d’accès compris) pour les répertoires du répertoire spécifié par path et qui correspondent au modèle de recherche spécifié.

Exceptions

Exemples

L’exemple suivant énumère les répertoires de niveau supérieur dans un chemin d’accès spécifié qui correspond à un modèle de recherche spécifié.

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, "dv_*")
                       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);
        }
    }
}

open System
open System.IO

try
    let dirPath = @"\\archives\2009\reports"

    let dirs = 
        Directory.EnumerateDirectories(dirPath, "dv_*")
        |> Seq.cache

    // Show results.
    for dir in dirs do
        // Remove path information from string.
        printfn $"{dir.Substring(dir.LastIndexOf '\\' + 1)}"
    printfn $"{Seq.length dirs} directories found."

    // Optionally create a list collection.
    let workDirs = Seq.toList dirs
    ()
    
with 
| :? UnauthorizedAccessException as uaEx ->
    printfn $"{uaEx.Message}"
| :? PathTooLongException as pathEx ->
    printfn $"{pathEx.Message}"

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, "dv_*")
            For Each folder In dirs
                ' Remove path infomration 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)

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

Remarques

searchPattern peut être une combinaison de caractères littéral et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Les caractères autres que le caractère générique sont des caractères littérals. Par exemple, la searchPattern chaîne « *t » recherche tous les noms se path terminant par la lettre « t ». La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

searchPattern ne peut pas se terminer par deux points (« .. ») ou contenir deux points (« .. ») suivis de DirectorySeparatorChar ou AltDirectorySeparatorChar, et il ne peut pas non plus contenir des caractères non valides. Vous pouvez rechercher les caractères non valides à l’aide de la méthode GetInvalidPathChars.

Vous pouvez spécifier des informations relatives ou absolues sur le chemin dans le path paramètre. Les informations relatives au chemin d’accès sont interprétées comme relatives au répertoire de travail actuel, que vous pouvez déterminer à l’aide de la GetCurrentDirectory méthode . Les noms de répertoires retournés sont précédés de la valeur que vous avez fournie dans le path paramètre. Par exemple, si vous fournissez un chemin relatif dans le paramètre, les path noms de répertoires retournés contiennent un chemin relatif.

Les EnumerateDirectories méthodes et GetDirectories diffèrent comme suit : lorsque vous utilisez EnumerateDirectories, vous pouvez commencer à énumérer la collection de noms avant que l’ensemble de la collection soit retourné ; lorsque vous utilisez GetDirectories, vous devez attendre que l’ensemble du tableau de noms soit retourné avant de pouvoir accéder au tableau. Par conséquent, lorsque vous travaillez avec de nombreux fichiers et répertoires, EnumerateDirectories peut être plus efficace.

La collection retournée n’est pas mise en cache ; chaque appel à sur GetEnumerator la collection démarre une nouvelle énumération.

Source:

Directory.cs

Source:

Directory.cs

Source:

Directory.cs

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern, System::IO::EnumerationOptions ^ enumerationOptions);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions);

static member EnumerateDirectories : string * string * System.IO.EnumerationOptions -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String, enumerationOptions As EnumerationOptions) As IEnumerable(Of String)

Paramètres

Retours

Collection énumérable des noms complets (chemins compris) pour les répertoires du répertoire spécifié par path et qui correspondent au modèle de recherche et aux options d’énumération spécifiés.

Exceptions

Remarques

searchPattern peut être une combinaison de caractères littéral et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Les caractères autres que le caractère générique sont des caractères littérals. Par exemple, la searchPattern chaîne « *t » recherche tous les noms se path terminant par la lettre « t ». La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

searchPattern ne peut pas se terminer par deux points (« .. ») ou contenir deux points (« .. ») suivis de DirectorySeparatorChar ou AltDirectorySeparatorChar, et il ne peut pas non plus contenir des caractères non valides. Vous pouvez rechercher les caractères non valides à l’aide de la méthode GetInvalidPathChars.

Vous pouvez spécifier des informations relatives ou absolues sur le chemin dans le path paramètre. Les informations relatives au chemin d’accès sont interprétées comme relatives au répertoire de travail actuel, que vous pouvez déterminer à l’aide de la GetCurrentDirectory méthode . Les noms de répertoires retournés sont précédés de la valeur que vous avez fournie dans le path paramètre . Par exemple, si vous fournissez un chemin d’accès relatif dans le path paramètre, les noms de répertoires retournés contiennent un chemin d’accès relatif.

Les EnumerateDirectories méthodes et GetDirectories diffèrent comme suit : lorsque vous utilisez EnumerateDirectories, vous pouvez commencer à énumérer la collection de noms avant que l’ensemble de la collection soit retourné ; lorsque vous utilisez GetDirectories, vous devez attendre que l’ensemble du tableau de noms soit retourné avant de pouvoir accéder au tableau. Par conséquent, lorsque vous travaillez avec de nombreux fichiers et répertoires, EnumerateDirectories peut être plus efficace.

La collection retournée n’est pas mise en cache ; chaque appel à sur GetEnumerator la collection démarre une nouvelle énumération.

Source:

Directory.cs

Source:

Directory.cs

Source:

Directory.cs

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern, System::IO::SearchOption searchOption);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern, System.IO.SearchOption searchOption);

static member EnumerateDirectories : string * string * System.IO.SearchOption -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String, searchOption As SearchOption) As IEnumerable(Of String)

Paramètres

Retours

Collection énumérable des noms complets (chemins compris) pour les répertoires du répertoire spécifié par path et qui correspondent au modèle et à l’option de recherche spécifiés.

Exceptions

Exemples

L’exemple suivant énumère les répertoires dans un chemin spécifié qui correspondent à un modèle de recherche spécifié. Il utilise le searchOption paramètre pour spécifier que tous les sous-répertoires doivent être inclus dans la recherche.

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, "dv_*",
                        SearchOption.AllDirectories)
                       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);
        }
    }
}

open System
open System.IO

try
    let dirPath = @"\\archives\2009\reports"

    let dirs =
        Directory.EnumerateDirectories(dirPath, "dv_*", SearchOption.AllDirectories)
        |> Seq.cache

    // Show results.
    for dir in dirs do
        // Remove path information from string.
        printfn $"{dir.Substring(dir.LastIndexOf '\\' + 1)}"
    printfn $"{Seq.length dirs} directories found."

    // Optionally create a List collection.
    let workDirs = Seq.toList dirs
    ()

with 
| :? UnauthorizedAccessException as uaEx ->
    printfn $"{uaEx.Message}"
| :? PathTooLongException as pathEx ->
    printfn $"{pathEx.Message}"

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, "dv_*", _
                    SearchOption.AllDirectories)
            For Each folder In dirs
                ' Remove path infomration 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)

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

Remarques

searchPattern peut être une combinaison de caractères littéraux et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Les caractères autres que le caractère générique sont des caractères littéraux. Par exemple, la searchPattern chaîne « *t » recherche tous les noms en path se terminant par la lettre « t ». La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

searchPattern ne peut pas se terminer par deux points (« .. ») ou contenir deux points (« .. ») suivis de DirectorySeparatorChar ou AltDirectorySeparatorChar, ni contenir des caractères non valides. Vous pouvez rechercher les caractères non valides à l’aide de la méthode GetInvalidPathChars.

Vous pouvez spécifier des informations relatives ou absolues sur le chemin dans le path paramètre . Les informations relatives au chemin d’accès sont interprétées comme relatives au répertoire de travail actuel, que vous pouvez déterminer à l’aide de la GetCurrentDirectory méthode . Les noms de répertoires retournés sont précédés de la valeur que vous avez fournie dans le path paramètre . Par exemple, si vous fournissez un chemin d’accès relatif dans le path paramètre, les noms de répertoires retournés contiennent un chemin d’accès relatif.

Les EnumerateDirectories méthodes et GetDirectories diffèrent comme suit : lorsque vous utilisez EnumerateDirectories, vous pouvez commencer à énumérer la collection de noms avant que l’ensemble de la collection soit retourné ; lorsque vous utilisez GetDirectories, vous devez attendre que l’ensemble du tableau de noms soit retourné avant de pouvoir accéder au tableau. Par conséquent, lorsque vous travaillez avec de nombreux fichiers et répertoires, EnumerateDirectories peut être plus efficace.

La collection retournée n’est pas mise en cache ; chaque appel à sur GetEnumerator la collection démarre une nouvelle énumération.